fix(ai-assistant): map apply_filter requestType to explorer panel type

"Open in Explorer" chips opened the Logs/Traces Explorer in the default raw
List view even when the agent's query was a grouped aggregation
(requestType=scalar with groupBy): applyFilter never set a panelTypes URL
param, so the explorer fell back to PANEL_TYPES.LIST.

Derive the panel type from the query's requestType (scalar/distribution ->
table, time_series -> graph, raw/other -> list) and set panelTypes on both the
on-page (redirectWithQueryBuilderData) and off-page (buildExplorerNavigationUrl)
navigation paths, mirroring the saved-view path that already worked. Removes
leftover [apply_filter] debug logs.

.vscode/settings.json

@@ -19,8 +19,5 @@
     "editor.defaultFormatter": "vscode.html-language-features"
   },
   "python-envs.defaultEnvManager": "ms-python.python:system",
-  "python-envs.pythonProjects": [],
-  "[json]": {
-    "editor.defaultFormatter": "vscode.json-language-features"
-  }
+  "python-envs.pythonProjects": []
 }

docs/api/openapi.yml

@@ -3566,6 +3566,10 @@ components:
           items:
             $ref: '#/components/schemas/ErrorsResponseerroradditional'
           type: array
+        invalidReferences:
+          items:
+            type: string
+          type: array
         message:
           type: string
         retry:
@@ -3586,10 +3590,6 @@ components:
       properties:
         message:
           type: string
-        suggestions:
-          items:
-            type: string
-          type: array
       type: object
     ErrorsResponseretryjson:
       properties:
@@ -9004,6 +9004,10 @@ paths:
           type: string
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "401":
           content:
@@ -9156,6 +9160,10 @@ paths:
               $ref: '#/components/schemas/DashboardtypesUpdatablePublicDashboard'
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "401":
           content:
@@ -9750,6 +9758,10 @@ paths:
               $ref: '#/components/schemas/Querybuildertypesv5QueryRangeRequest'
       responses:
         "200":
+          content:
+            application/json:
+              schema:
+                type: string
           description: OK
         "400":
           content:
@@ -10934,6 +10946,10 @@ paths:
           type: string
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "401":
           content:
@@ -11047,6 +11063,10 @@ paths:
               $ref: '#/components/schemas/AuthtypesPatchableRole'
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "401":
           content:
@@ -11193,6 +11213,10 @@ paths:
               $ref: '#/components/schemas/CoretypesPatchableObjects'
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "400":
           content:
@@ -11642,6 +11666,10 @@ paths:
           type: string
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "401":
           content:
@@ -11749,6 +11777,10 @@ paths:
               $ref: '#/components/schemas/ServiceaccounttypesPostableServiceAccount'
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "400":
           content:
@@ -11930,6 +11962,10 @@ paths:
           type: string
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "401":
           content:
@@ -11987,6 +12023,10 @@ paths:
               $ref: '#/components/schemas/ServiceaccounttypesUpdatableFactorAPIKey'
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "400":
           content:
@@ -12169,6 +12209,10 @@ paths:
           type: string
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "401":
           content:
@@ -12244,6 +12288,10 @@ paths:
               $ref: '#/components/schemas/ServiceaccounttypesPostableServiceAccount'
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "404":
           content:
@@ -12735,53 +12783,6 @@ paths:
       summary: Update a span mapper
       tags:
       - spanmapper
-  /api/v1/stats:
-    get:
-      deprecated: false
-      description: This endpoint returns the collected stats for the organization
-      operationId: GetStats
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    additionalProperties: {}
-                    type: object
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Get stats
-      tags:
-      - stats
   /api/v1/testChannel:
     post:
       deprecated: true
@@ -13468,6 +13469,10 @@ paths:
           type: string
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "400":
           content:
@@ -13727,6 +13732,10 @@ paths:
           type: string
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "400":
           content:
@@ -13779,6 +13788,10 @@ paths:
           type: string
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "400":
           content:
@@ -15509,6 +15522,10 @@ paths:
               $ref: '#/components/schemas/MetricsexplorertypesUpdateMetricMetadataRequest'
       responses:
         "200":
+          content:
+            application/json:
+              schema:
+                type: string
           description: OK
         "400":
           content:
@@ -20807,6 +20824,10 @@ paths:
           type: string
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "400":
           content:
@@ -20854,6 +20875,10 @@ paths:
           type: string
       responses:
         "204":
+          content:
+            application/json:
+              schema:
+                type: string
           description: No Content
         "400":
           content:

docs/contributing/go/handler.md

@@ -109,20 +109,6 @@ func (h *handler) CreateThing(rw http.ResponseWriter, req *http.Request) {
 }
 ```
 
-When you need an ID from `claims` as a `valuer.UUID` (for example to pass it to a module), derive it with the `Must*` constructor instead of `NewUUID` plus an error check. Claims are validated by the auth middleware, so the conversion cannot fail and the error branch would be dead code:
-
-```go
-// Good — claims are pre-validated, the conversion cannot fail.
-orgID := valuer.MustNewUUID(claims.OrgID)
-
-// Avoid — the error path is unreachable.
-orgID, err := valuer.NewUUID(claims.OrgID)
-if err != nil {
-    render.Error(rw, err)
-    return
-}
-```
-
 ### 3. Register the handler in `signozapiserver`
 
 In `pkg/apiserver/signozapiserver`, add a route in the appropriate `add*Routes` function (`addUserRoutes`, `addSessionRoutes`, `addOrgRoutes`, etc.). The pattern is:
@@ -401,4 +387,3 @@ Note the discriminator property lives in the variants, not on the parent — the
 - **Add `nullable:"true"`** on fields that can be `null`. Pay special attention to slices and maps -- in Go these default to `nil` which serializes to `null`. If the field should always be an array, initialize it and do not mark it nullable.
 - **Implement `Enum()`** on every type that has a fixed set of acceptable values so the JSON schema generates proper `enum` constraints.
 - **Add request examples** via `RequestExamples` in `OpenAPIDef` for any non-trivial endpoint. See `pkg/apiserver/signozapiserver/querier.go` for reference.
-- **Derive IDs from `claims` with `valuer.MustNewUUID`** (e.g. `claims.OrgID`, `claims.UserID`). Claims are pre-validated by the auth middleware, so use the `Must*` constructor — don't write `NewUUID` followed by an `if err != nil { render.Error(...); return }` block.

ee/querier/handler.go

@@ -3,13 +3,13 @@ package querier
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"io"
 	"net/http"
 
 	anomalyV2 "github.com/SigNoz/signoz/ee/anomaly"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/http/binding"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
@@ -48,8 +48,8 @@ func (h *handler) QueryRange(rw http.ResponseWriter, req *http.Request) {
 	}
 
 	var queryRangeRequest qbtypes.QueryRangeRequest
-	if err := binding.JSON.BindBody(req.Body, &queryRangeRequest); err != nil {
-		render.Error(rw, err)
+	if err := json.NewDecoder(req.Body).Decode(&queryRangeRequest); err != nil {
+		render.Error(rw, errors.NewInvalidInputf(errors.CodeInvalidInput, "failed to decode request body: %v", err))
 		return
 	}
 

frontend/src/api/ai-assistant/sigNozAIAssistantAPI.schemas.ts

@@ -159,6 +159,25 @@ export interface CancelResponseDTO {
 	state: ExecutionStateDTO;
 }
 
+export interface ChipDTO {
+	/**
+	 * @type string
+	 * @description Stable chip id. Rule-engine chips use intent ids.
+	 */
+	id: string;
+	/**
+	 * @type string
+	 */
+	text: string;
+}
+
+export interface ChipsResponseDTO {
+	/**
+	 * @type array
+	 */
+	chips: ChipDTO[];
+}
+
 export type ClarificationFieldDTOOptions = string[] | null;
 
 export type ClarificationFieldDTODefault = string | string[] | null;
@@ -386,15 +405,74 @@ export type ErrorBodyDTOErrors = ErrorResponseAdditionalDTO[] | null;
 
 export type ErrorBodyDTOUrl = string | null;
 
+/**
+   * Machine-readable error codes carried on ``ErrorBody.code``.
+  
+  **Extensible set.** This enum is the single source of truth for every code
+  the backend can emit, on both the REST envelope and the SSE ``ErrorEvent``.
+  It is published in the OpenAPI schema (and therefore the generated TS
+  client) so clients get autocomplete and a typed discriminant. The set is
+  expected to *grow*: adding a member is a backward-compatible change (the
+  wire is still a plain JSON string), so clients MUST treat unknown codes
+  gracefully — branch on the codes they handle and keep a default fallback,
+  never hard-reject an unrecognized value. Re-exported from ``app.errors``
+  for convenience; ``AssistantError(code=...)`` requires a member of this
+  enum so a typo can never reach a client.
+   */
+export enum ErrorCodeDTO {
+	missing_signoz_url = 'missing_signoz_url',
+	invalid_signoz_url = 'invalid_signoz_url',
+	invalid_content_length = 'invalid_content_length',
+	invalid_fork_target = 'invalid_fork_target',
+	rate_limit_override_exceeds_ceiling = 'rate_limit_override_exceeds_ceiling',
+	thread_message_limit = 'thread_message_limit',
+	validation_error = 'validation_error',
+	missing_token = 'missing_token',
+	invalid_token = 'invalid_token',
+	permission_denied = 'permission_denied',
+	user_disabled = 'user_disabled',
+	org_disabled = 'org_disabled',
+	thread_not_found = 'thread_not_found',
+	message_not_found = 'message_not_found',
+	execution_not_found = 'execution_not_found',
+	approval_not_found = 'approval_not_found',
+	clarification_not_found = 'clarification_not_found',
+	action_metadata_not_found = 'action_metadata_not_found',
+	user_not_found = 'user_not_found',
+	region_not_configured = 'region_not_configured',
+	thread_busy = 'thread_busy',
+	thread_has_active_execution = 'thread_has_active_execution',
+	no_active_execution = 'no_active_execution',
+	approval_superseded = 'approval_superseded',
+	clarification_superseded = 'clarification_superseded',
+	undo_conflict = 'undo_conflict',
+	revert_conflict = 'revert_conflict',
+	revert_expired = 'revert_expired',
+	restore_expired = 'restore_expired',
+	connection_limit_exceeded = 'connection_limit_exceeded',
+	hourly_message_limit = 'hourly_message_limit',
+	daily_message_limit = 'daily_message_limit',
+	daily_token_limit = 'daily_token_limit',
+	daily_cost_limit = 'daily_cost_limit',
+	upstream_auth_error = 'upstream_auth_error',
+	max_turns_exceeded = 'max_turns_exceeded',
+	budget_exceeded = 'budget_exceeded',
+	agent_execution_error = 'agent_execution_error',
+	cli_not_found = 'cli_not_found',
+	cli_connection_error = 'cli_connection_error',
+	cli_process_error = 'cli_process_error',
+	sandbox_unavailable = 'sandbox_unavailable',
+	mcp_unavailable = 'mcp_unavailable',
+	internal_error = 'internal_error',
+	region_unreachable = 'region_unreachable',
+	heartbeat_expired = 'heartbeat_expired',
+	replay_unavailable = 'replay_unavailable',
+}
 /**
  * Inner error object — matches Go ErrorsJSON.
  */
 export interface ErrorBodyDTO {
-	/**
-	 * @type string
-	 * @pattern ^[a-z_]+$
-	 */
-	code: string;
+	code: ErrorCodeDTO;
 	/**
 	 * @type string
 	 */
@@ -490,6 +568,23 @@ export type MessageActionDTOQuery = MessageActionDTOQueryAnyOf | null;
 
 export type MessageActionDTOUrl = string | null;
 
+/**
+   * Explorer namespace a saved view belongs to — its ``sourcePage``.
+  
+  Mirrors the SigNoz product's saved-view ``sourcePage`` values so the
+  frontend can route an ``open_resource`` action for a view to the right
+  Explorer via its existing ``SOURCEPAGE_VS_ROUTES`` map. ``meter`` is the
+  Cost Meter Explorer and is intentionally distinct from ``metrics`` (the
+  product persists and lists meter views under ``sourcePage="meter"``).
+   */
+export enum SavedViewEntityDTO {
+	logs = 'logs',
+	traces = 'traces',
+	metrics = 'metrics',
+	meter = 'meter',
+}
+export type MessageActionDTOEntity = SavedViewEntityDTO | null;
+
 export enum MessageActionKindDTO {
 	undo = 'undo',
 	revert = 'revert',
@@ -500,7 +595,7 @@ export enum MessageActionKindDTO {
 	apply_filter = 'apply_filter',
 }
 /**
- * Assistant action. Kind-specific requirements: rollback actions require actionMetadataId/resourceType/resourceId; follow_up requires input.intent; open_resource requires resourceType/resourceId; apply_filter requires signal and query; open_docs requires a SigNoz docs url.
+ * Assistant action. Kind-specific requirements: rollback actions require actionMetadataId/resourceType/resourceId; follow_up requires input.intent; open_resource requires resourceType/resourceId; apply_filter requires signal and query; open_docs requires a SigNoz docs url. open_resource for a saved view also carries entity (logs/traces/metrics/meter) so the frontend routes to the correct Explorer.
  */
 export interface MessageActionDTO {
 	kind: MessageActionKindDTO;
@@ -517,6 +612,7 @@ export interface MessageActionDTO {
 	signal?: MessageActionDTOSignal;
 	query?: MessageActionDTOQuery;
 	url?: MessageActionDTOUrl;
+	entity?: MessageActionDTOEntity;
 }
 
 export enum MessageContentTypeDTO {
@@ -590,6 +686,26 @@ export interface MessageSummaryDTO {
 	updatedAt: string;
 }
 
+export enum PageTypeDTO {
+	homepage = 'homepage',
+	dashboard_detail = 'dashboard_detail',
+	dashboard_list = 'dashboard_list',
+	panel_edit = 'panel_edit',
+	panel_fullscreen = 'panel_fullscreen',
+	logs_explorer = 'logs_explorer',
+	log_detail = 'log_detail',
+	traces_explorer = 'traces_explorer',
+	trace_detail = 'trace_detail',
+	metrics_explorer = 'metrics_explorer',
+	service_detail = 'service_detail',
+	services_list = 'services_list',
+	alert_edit = 'alert_edit',
+	alert_list = 'alert_list',
+	alert_new = 'alert_new',
+	alerts_triggered = 'alerts_triggered',
+	infra_entity_detail = 'infra_entity_detail',
+	other = 'other',
+}
 export enum ReadinessChecksDTODatabase {
 	ok = 'ok',
 	failed = 'failed',
@@ -990,8 +1106,10 @@ export type MessageActionEventDTOQuery = MessageActionEventDTOQueryAnyOf | null;
 
 export type MessageActionEventDTOUrl = string | null;
 
+export type MessageActionEventDTOEntity = SavedViewEntityDTO | null;
+
 /**
- * Assistant action. Kind-specific requirements: rollback actions require actionMetadataId/resourceType/resourceId; follow_up requires input.intent; open_resource requires resourceType/resourceId; apply_filter requires signal and query; open_docs requires a SigNoz docs url.
+ * Assistant action. Kind-specific requirements: rollback actions require actionMetadataId/resourceType/resourceId; follow_up requires input.intent; open_resource requires resourceType/resourceId; apply_filter requires signal and query; open_docs requires a SigNoz docs url. open_resource for a saved view also carries entity (logs/traces/metrics/meter) so the frontend routes to the correct Explorer.
  */
 export interface MessageActionEventDTO {
 	kind: MessageActionKindDTO;
@@ -1008,6 +1126,7 @@ export interface MessageActionEventDTO {
 	signal?: MessageActionEventDTOSignal;
 	query?: MessageActionEventDTOQuery;
 	url?: MessageActionEventDTOUrl;
+	entity?: MessageActionEventDTOEntity;
 }
 
 export type MessageEventDTOActions = MessageActionEventDTO[] | null;
@@ -1385,3 +1504,21 @@ export type GetUsageApiV1AssistantUsageGetHeaders = {
 	 */
 	'X-SigNoz-URL'?: string | null;
 };
+
+export type GetChipsApiV1AssistantEmptyStateChipsGetParams = {
+	/**
+	 * @description Frontend-declared page type. Typed as an enum, but unrecognized values are coerced to 'other' (not rejected) so a new frontend page type works before the backend knows it. The page type alone identifies the focused entity (e.g. trace_detail) for the 'Explain this …' chip; the agent reads the concrete entity from page context once a chip is clicked, so no separate entity id is needed.
+	 */
+	page_type: PageTypeDTO;
+};
+
+export type GetChipsApiV1AssistantEmptyStateChipsGetHeaders = {
+	/**
+	 * @description SigNoz auth token (Bearer or raw JWT)
+	 */
+	authorization?: string | null;
+	/**
+	 * @description SigNoz instance base URL for multi-tenant deployments. Falls back to SIGNOZ_API_URL env var when omitted.
+	 */
+	'X-SigNoz-URL'?: string | null;
+};

frontend/src/api/generated/services/dashboard/index.ts

@@ -63,7 +63,7 @@ export const deletePublicDashboard = (
 	{ id }: DeletePublicDashboardPathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/dashboards/${id}/public`,
 		method: 'DELETE',
 		signal,
@@ -346,7 +346,7 @@ export const updatePublicDashboard = (
 	dashboardtypesUpdatablePublicDashboardDTO?: BodyType<DashboardtypesUpdatablePublicDashboardDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/dashboards/${id}/public`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
@@ -836,7 +836,7 @@ export const deleteDashboardV2 = (
 	{ id }: DeleteDashboardV2PathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/dashboards/${id}`,
 		method: 'DELETE',
 		signal,
@@ -1214,7 +1214,7 @@ export const unlockDashboardV2 = (
 	{ id }: UnlockDashboardV2PathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/dashboards/${id}/lock`,
 		method: 'DELETE',
 		signal,
@@ -1293,7 +1293,7 @@ export const lockDashboardV2 = (
 	{ id }: LockDashboardV2PathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/dashboards/${id}/lock`,
 		method: 'PUT',
 		signal,
@@ -1471,7 +1471,7 @@ export const unpinDashboardV2 = (
 	{ id }: UnpinDashboardV2PathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/users/me/dashboards/${id}/pins`,
 		method: 'DELETE',
 		signal,
@@ -1550,7 +1550,7 @@ export const pinDashboardV2 = (
 	{ id }: PinDashboardV2PathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/users/me/dashboards/${id}/pins`,
 		method: 'PUT',
 		signal,

frontend/src/api/generated/services/logs/index.ts

@@ -37,7 +37,7 @@ export const handleExportRawDataPOST = (
 	params?: HandleExportRawDataPOSTParams,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/export_raw_data`,
 		method: 'POST',
 		headers: { 'Content-Type': 'application/json' },

frontend/src/api/generated/services/metrics/index.ts

@@ -680,7 +680,7 @@ export const updateMetricMetadata = (
 	metricsexplorertypesUpdateMetricMetadataRequestDTO?: BodyType<MetricsexplorertypesUpdateMetricMetadataRequestDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v2/metrics/${metricName}/metadata`,
 		method: 'POST',
 		headers: { 'Content-Type': 'application/json' },

frontend/src/api/generated/services/role/index.ts

@@ -203,7 +203,7 @@ export const deleteRole = (
 	{ id }: DeleteRolePathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/roles/${id}`,
 		method: 'DELETE',
 		signal,
@@ -372,7 +372,7 @@ export const patchRole = (
 	authtypesPatchableRoleDTO?: BodyType<AuthtypesPatchableRoleDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/roles/${id}`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },
@@ -572,7 +572,7 @@ export const patchObjects = (
 	coretypesPatchableObjectsDTO?: BodyType<CoretypesPatchableObjectsDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/roles/${id}/relations/${relation}/objects`,
 		method: 'PATCH',
 		headers: { 'Content-Type': 'application/json' },

frontend/src/api/generated/services/serviceaccount/index.ts

@@ -222,7 +222,7 @@ export const deleteServiceAccount = (
 	{ id }: DeleteServiceAccountPathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}`,
 		method: 'DELETE',
 		signal,
@@ -405,7 +405,7 @@ export const updateServiceAccount = (
 	serviceaccounttypesPostableServiceAccountDTO?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
@@ -707,7 +707,7 @@ export const revokeServiceAccountKey = (
 	{ id, fid }: RevokeServiceAccountKeyPathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}/keys/${fid}`,
 		method: 'DELETE',
 		signal,
@@ -788,7 +788,7 @@ export const updateServiceAccountKey = (
 	serviceaccounttypesUpdatableFactorAPIKeyDTO?: BodyType<ServiceaccounttypesUpdatableFactorAPIKeyDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}/keys/${fid}`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },
@@ -1090,7 +1090,7 @@ export const deleteServiceAccountRole = (
 	{ id, rid }: DeleteServiceAccountRolePathParameters,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/${id}/roles/${rid}`,
 		method: 'DELETE',
 		signal,
@@ -1254,7 +1254,7 @@ export const updateMyServiceAccount = (
 	serviceaccounttypesPostableServiceAccountDTO?: BodyType<ServiceaccounttypesPostableServiceAccountDTO>,
 	signal?: AbortSignal,
 ) => {
-	return GeneratedAPIInstance<void>({
+	return GeneratedAPIInstance<string>({
 		url: `/api/v1/service_accounts/me`,
 		method: 'PUT',
 		headers: { 'Content-Type': 'application/json' },

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

@@ -2143,10 +2143,6 @@ export interface ErrorsResponseerroradditionalDTO {
 	 * @type string
 	 */
 	message?: string;
-	/**
-	 * @type array
-	 */
-	suggestions?: string[];
 }
 
 export interface ErrorsResponseretryjsonDTO {
@@ -2162,6 +2158,10 @@ export interface ErrorsJSONDTO {
 	 * @type array
 	 */
 	errors?: ErrorsResponseerroradditionalDTO[];
+	/**
+	 * @type array
+	 */
+	invalidReferences?: string[];
 	/**
 	 * @type string
 	 */
@@ -9736,19 +9736,6 @@ export type UpdateSpanMapperPathParameters = {
 	groupId: string;
 	mapperId: string;
 };
-export type GetStats200Data = { [key: string]: unknown };
-
-export type GetStats200 = {
-	/**
-	 * @type object
-	 */
-	data: GetStats200Data;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetTraceAggregationsPathParameters = {
 	traceID: string;
 };

frontend/src/api/generated/services/stats/index.ts

@@ -1,96 +0,0 @@
-/**
- * ! Do not edit manually
- * * The file has been auto-generated using Orval for SigNoz
- * * regenerate with 'pnpm generate:api'
- * SigNoz
- */
-import { useQuery } from 'react-query';
-import type {
-	InvalidateOptions,
-	QueryClient,
-	QueryFunction,
-	QueryKey,
-	UseQueryOptions,
-	UseQueryResult,
-} from 'react-query';
-
-import type { GetStats200, RenderErrorResponseDTO } from '../sigNoz.schemas';
-
-import { GeneratedAPIInstance } from '../../../generatedAPIInstance';
-import type { ErrorType } from '../../../generatedAPIInstance';
-
-/**
- * This endpoint returns the collected stats for the organization
- * @summary Get stats
- */
-export const getStats = (signal?: AbortSignal) => {
-	return GeneratedAPIInstance<GetStats200>({
-		url: `/api/v1/stats`,
-		method: 'GET',
-		signal,
-	});
-};
-
-export const getGetStatsQueryKey = () => {
-	return [`/api/v1/stats`] as const;
-};
-
-export const getGetStatsQueryOptions = <
-	TData = Awaited<ReturnType<typeof getStats>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof getStats>>, TError, TData>;
-}) => {
-	const { query: queryOptions } = options ?? {};
-
-	const queryKey = queryOptions?.queryKey ?? getGetStatsQueryKey();
-
-	const queryFn: QueryFunction<Awaited<ReturnType<typeof getStats>>> = ({
-		signal,
-	}) => getStats(signal);
-
-	return { queryKey, queryFn, ...queryOptions } as UseQueryOptions<
-		Awaited<ReturnType<typeof getStats>>,
-		TError,
-		TData
-	> & { queryKey: QueryKey };
-};
-
-export type GetStatsQueryResult = NonNullable<
-	Awaited<ReturnType<typeof getStats>>
->;
-export type GetStatsQueryError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get stats
- */
-
-export function useGetStats<
-	TData = Awaited<ReturnType<typeof getStats>>,
-	TError = ErrorType<RenderErrorResponseDTO>,
->(options?: {
-	query?: UseQueryOptions<Awaited<ReturnType<typeof getStats>>, TError, TData>;
-}): UseQueryResult<TData, TError> & { queryKey: QueryKey } {
-	const queryOptions = getGetStatsQueryOptions(options);
-
-	const query = useQuery(queryOptions) as UseQueryResult<TData, TError> & {
-		queryKey: QueryKey;
-	};
-
-	return { ...query, queryKey: queryOptions.queryKey };
-}
-
-/**
- * @summary Get stats
- */
-export const invalidateGetStats = async (
-	queryClient: QueryClient,
-	options?: InvalidateOptions,
-): Promise<QueryClient> => {
-	await queryClient.invalidateQueries(
-		{ queryKey: getGetStatsQueryKey() },
-		options,
-	);
-
-	return queryClient;
-};

frontend/src/api/saveView/getViewById.ts

@@ -0,0 +1,24 @@
+import axios from 'api';
+import { AxiosResponse } from 'axios';
+import { ViewProps } from 'types/api/saveViews/types';
+
+/**
+ * Fetches a single saved view by ID (`GET /api/v1/explorer/views/{viewId}`).
+ *
+ * Hand-maintained alongside the other `api/saveView/*` clients — explorer views
+ * are not in `docs/api/openapi.yml`, so Orval does not generate a hook here
+ * (unlike e.g. `useGetChannelByID` under `api/generated/services/channels`).
+ *
+ * Used by the AI assistant "Open view" action to load `compositeQuery` and
+ * navigate to the correct explorer without listing every view per source page.
+ * See `container/AIAssistant/components/ActionsSection/utils/openSavedView.ts`.
+ */
+export interface GetViewByIdProps {
+	status: string;
+	data: ViewProps;
+}
+
+export const getViewById = (
+	viewKey: string,
+): Promise<AxiosResponse<GetViewByIdProps>> =>
+	axios.get(`/explorer/views/${viewKey}`);

frontend/src/components/RouteTab/RouteTab.test.tsx

@@ -90,20 +90,4 @@ describe('RouteTab component', () => {
 		fireEvent.click(screen.getByRole('tab', { name: 'Tab2' }));
 		expect(onChangeHandler).toHaveBeenCalled();
 	});
-
-	it('unmounts inactive tab pane content after switching', () => {
-		const history = createMemoryHistory({ initialEntries: ['/tab1'] });
-		render(
-			<Router history={history}>
-				<RouteTab history={history} routes={testRoutes} activeKey="Tab1" />
-			</Router>,
-		);
-
-		expect(screen.getByText('Dummy Component 1')).toBeInTheDocument();
-
-		fireEvent.click(screen.getByRole('tab', { name: 'Tab2' }));
-
-		expect(screen.queryByText('Dummy Component 1')).not.toBeInTheDocument();
-		expect(screen.getByText('Dummy Component 2')).toBeInTheDocument();
-	});
 });

frontend/src/components/RouteTab/index.tsx

@@ -59,7 +59,7 @@ function RouteTab({
 			destroyInactiveTabPane
 			activeKey={currentRoute?.key || activeKey}
 			defaultActiveKey={currentRoute?.key || activeKey}
-			animated={{ inkBar: true, tabPane: false }}
+			animated
 			items={items}
 			tabBarExtraContent={
 				showRightSection && (

frontend/src/container/AIAssistant/__tests__/getAutoContexts.test.ts

@@ -0,0 +1,89 @@
+import { QueryParams } from 'constants/query';
+import ROUTES from 'constants/routes';
+
+import { getAutoContexts } from '../getAutoContexts';
+
+describe('getAutoContexts', () => {
+	it('returns alert detail context on alert overview with ruleId', () => {
+		const ruleId = 'rule-abc';
+		const search = `?${QueryParams.ruleId}=${ruleId}&${QueryParams.relativeTime}=1h`;
+
+		const contexts = getAutoContexts(ROUTES.ALERT_OVERVIEW, search);
+
+		expect(contexts).toStrictEqual([
+			{
+				source: 'auto',
+				type: 'alert',
+				resourceId: ruleId,
+				metadata: {
+					page: 'alert_detail',
+					ruleId,
+				},
+			},
+		]);
+	});
+
+	it('returns alert detail context on alert history with ruleId', () => {
+		const ruleId = 'rule-xyz';
+		const startTime = '1700000000000';
+		const endTime = '1700003600000';
+		const search = `?${QueryParams.ruleId}=${ruleId}&${QueryParams.startTime}=${startTime}&${QueryParams.endTime}=${endTime}`;
+
+		const contexts = getAutoContexts(ROUTES.ALERT_HISTORY, search);
+
+		expect(contexts).toStrictEqual([
+			{
+				source: 'auto',
+				type: 'alert',
+				resourceId: ruleId,
+				metadata: {
+					page: 'alert_detail',
+					ruleId,
+					timeRange: {
+						start: Number(startTime),
+						end: Number(endTime),
+					},
+				},
+			},
+		]);
+	});
+
+	it('returns triggered alerts context on alert history without ruleId', () => {
+		const contexts = getAutoContexts(ROUTES.ALERT_HISTORY, '');
+
+		expect(contexts).toStrictEqual([
+			{
+				source: 'auto',
+				type: 'alert',
+				resourceId: null,
+				metadata: {
+					page: 'alerts_triggered',
+				},
+			},
+		]);
+	});
+
+	it('returns dashboard detail context on dashboard page', () => {
+		const dashboardId = 'dash-123';
+		const pathname = ROUTES.DASHBOARD.replace(':dashboardId', dashboardId);
+
+		const contexts = getAutoContexts(pathname, '');
+
+		expect(contexts).toStrictEqual([
+			{
+				source: 'auto',
+				type: 'dashboard',
+				resourceId: dashboardId,
+				metadata: {
+					page: 'dashboard_detail',
+				},
+			},
+		]);
+	});
+
+	it('returns empty array on alert overview without ruleId', () => {
+		const contexts = getAutoContexts(ROUTES.ALERT_OVERVIEW, '');
+
+		expect(contexts).toStrictEqual([]);
+	});
+});

frontend/src/container/AIAssistant/components/ActionsSection/ActionsSection.tsx

@@ -47,6 +47,22 @@ import { AIAssistantEvents, SuggestedPromptCategory } from '../../events';
 import { useAIAssistantAnalyticsContext } from '../../hooks/useAIAssistantAnalyticsContext';
 import { useAIAssistantStore } from '../../store/useAIAssistantStore';
 
+import {
+	getPanelTypeForRequestType,
+	requestTypeFromActionQuery,
+} from './utils/applyFilterPanelType';
+import {
+	buildExplorerNavigationUrl,
+	openSavedViewByKey,
+} from './utils/openSavedView';
+import {
+	isSavedViewOpenAction,
+	resolveOpenResourceType,
+	resolveResourceId,
+	resolveSavedViewSourceHint,
+} from './utils/resolveOpenResource';
+import { ResourceType, resourceRoute } from './utils/resourceRoute';
+
 import styles from './ActionsSection.module.scss';
 
 interface ActionsSectionProps {
@@ -55,20 +71,6 @@ interface ActionsSectionProps {
 	messageId: string;
 }
 
-/**
- * Resource-type strings the backend uses for `open_resource` and rollback
- * actions. Centralized here so the route/module lookups below stay in sync.
- */
-const ResourceType = {
-	dashboard: 'dashboard',
-	alert: 'alert',
-	service: 'service',
-	saved_view: 'saved_view',
-	logs_explorer: 'logs_explorer',
-	traces_explorer: 'traces_explorer',
-	metrics_explorer: 'metrics_explorer',
-} as const;
-
 /** Maps an open_resource action's resourceType to its product module name. */
 function targetModuleForResource(resourceType: string): string | null {
 	switch (resourceType) {
@@ -78,6 +80,8 @@ function targetModuleForResource(resourceType: string): string | null {
 			return 'alerts';
 		case ResourceType.service:
 			return 'apm';
+		case ResourceType.channel:
+			return 'channels';
 		case ResourceType.saved_view:
 			return 'savedViews';
 		case ResourceType.logs_explorer:
@@ -140,39 +144,6 @@ function ActionIcon({
 	}
 }
 
-/**
- * Resolves an `open_resource` action to an in-app route.
- * Resource taxonomy mirrors `MessageContextDTOType`: dashboard, alert,
- * saved_view, service, and the *_explorer signals.
- */
-function resourceRoute(
-	resourceType: string,
-	resourceId: string,
-): string | null {
-	switch (resourceType) {
-		case ResourceType.dashboard:
-			return ROUTES.DASHBOARD.replace(':dashboardId', resourceId);
-		case ResourceType.alert: {
-			const params = new URLSearchParams({ [QueryParams.ruleId]: resourceId });
-			return `${ROUTES.EDIT_ALERTS}?${params.toString()}`;
-		}
-		case ResourceType.service:
-			return ROUTES.SERVICE_METRICS.replace(':servicename', resourceId);
-		case ResourceType.saved_view:
-			// No detail route — saved views land on the list page.
-			// Caller may provide signal-aware metadata in future; default to logs.
-			return ROUTES.LOGS_SAVE_VIEWS;
-		case ResourceType.logs_explorer:
-			return ROUTES.LOGS_EXPLORER;
-		case ResourceType.traces_explorer:
-			return ROUTES.TRACES_EXPLORER;
-		case ResourceType.metrics_explorer:
-			return ROUTES.METRICS_EXPLORER_EXPLORER;
-		default:
-			return null;
-	}
-}
-
 /**
  * The agent emits `action.query` as the SigNoz REST query-range request body:
  *
@@ -359,48 +330,41 @@ function withDerivedFilterExpressions(query: Query): Query {
  *     the new URL on mount.
  */
 function applyFilter(action: MessageActionDTO, deps: ApplyFilterDeps): void {
-	// eslint-disable-next-line no-console
-	console.log('[apply_filter] enter', {
-		signal: action.signal,
-		query: action.query,
-		pathname: deps.pathname,
-	});
 	if (!action.signal || !action.query) {
-		// eslint-disable-next-line no-console
-		console.warn('[apply_filter] bail: missing signal or query', action);
 		return;
 	}
 	const urlQuery = toUrlCompositeQuery(action.query as Record<string, unknown>);
 	if (!urlQuery) {
-		// eslint-disable-next-line no-console
-		console.warn(
-			'[apply_filter] bail: toUrlCompositeQuery returned null — agent payload shape unrecognized',
-			action.query,
-		);
 		return;
 	}
+	// `requestType` lives on the request envelope, which `toUrlCompositeQuery`
+	// drops — read it off the raw action query and translate it into the
+	// explorer panel type so a grouped/aggregated query opens as a table/graph
+	// instead of the default raw-log List view.
+	const panelType = getPanelTypeForRequestType(
+		requestTypeFromActionQuery(action.query as Record<string, unknown>),
+	);
 	const normalized = withDerivedFilterExpressions(urlQuery as unknown as Query);
-	// eslint-disable-next-line no-console
-	console.log('[apply_filter] normalized', normalized);
 	if (signalMatchesPathname(action.signal, deps.pathname)) {
-		// eslint-disable-next-line no-console
-		console.log('[apply_filter] on-page → handleSetQueryData + redirect');
 		normalized.builder.queryData.forEach((q, i) => {
 			deps.handleSetQueryData(i, q);
 		});
-		deps.redirectWithQueryBuilderData(normalized);
+		deps.redirectWithQueryBuilderData(normalized, {
+			[QueryParams.panelTypes]: panelType,
+		});
 		return;
 	}
 	const base = explorerRouteForSignal(action.signal);
 	if (!base) {
-		// eslint-disable-next-line no-console
-		console.warn('[apply_filter] bail: no route for signal', action.signal);
 		return;
 	}
-	// eslint-disable-next-line no-console
-	console.log('[apply_filter] off-page → history.push', base);
-	const encoded = encodeURIComponent(JSON.stringify(normalized));
-	deps.history.push(`${base}?${QueryParams.compositeQuery}=${encoded}`);
+	// Reuse the saved-view URL builder so the encoding (double-encoded
+	// compositeQuery + JSON-stringified panelTypes) matches what the explorer's
+	// URL parser expects — see useGetCompositeQueryParam / useGetPanelTypesQueryParam.
+	const url = buildExplorerNavigationUrl(base, normalized, {
+		[QueryParams.panelTypes]: panelType,
+	});
+	deps.history.push(url);
 }
 
 /** Picks the right rollback API call for a given action kind. */
@@ -484,6 +448,35 @@ export default function ActionsSection({
 		setResults((prev) => ({ ...prev, [key]: result }));
 	};
 
+	const runOpenSavedView = async (
+		key: string,
+		action: MessageActionDTO,
+	): Promise<void> => {
+		const resourceId = resolveResourceId(action);
+		if (!resourceId) {
+			return;
+		}
+		setResult(key, { state: 'loading' });
+		try {
+			await openSavedViewByKey(
+				resourceId,
+				resolveSavedViewSourceHint(action),
+				history,
+			);
+			void logEvent(AIAssistantEvents.ResourceOpened, {
+				threadId,
+				messageId,
+				targetModule: targetModuleForResource(ResourceType.saved_view),
+				resourceId,
+			});
+			setResult(key, { state: 'success' });
+		} catch (err) {
+			const message =
+				err instanceof Error ? err.message : 'Failed to open saved view';
+			setResult(key, { state: 'error', error: message });
+		}
+	};
+
 	const runRollback = async (
 		key: string,
 		action: MessageActionDTO,
@@ -502,6 +495,31 @@ export default function ActionsSection({
 		}
 	};
 
+	const handleOpenResource = (key: string, action: MessageActionDTO): void => {
+		if (isSavedViewOpenAction(action)) {
+			void runOpenSavedView(key, action);
+			return;
+		}
+
+		const resourceType = resolveOpenResourceType(action);
+		const resourceId = resolveResourceId(action);
+		if (!resourceType || !resourceId) {
+			return;
+		}
+
+		const path = resourceRoute(resourceType, resourceId);
+		if (!path) {
+			return;
+		}
+		void logEvent(AIAssistantEvents.ResourceOpened, {
+			threadId,
+			messageId,
+			targetModule: targetModuleForResource(resourceType),
+			resourceId,
+		});
+		history.push(path);
+	};
+
 	const handleClick = (key: string, action: MessageActionDTO): void => {
 		switch (action.kind) {
 			case MessageActionKindDTO.open_docs: {
@@ -542,21 +560,9 @@ export default function ActionsSection({
 				}
 				break;
 			}
-			case MessageActionKindDTO.open_resource: {
-				if (action.resourceType && action.resourceId) {
-					const path = resourceRoute(action.resourceType, action.resourceId);
-					if (path) {
-						void logEvent(AIAssistantEvents.ResourceOpened, {
-							threadId,
-							messageId,
-							targetModule: targetModuleForResource(action.resourceType),
-							resourceId: action.resourceId,
-						});
-						history.push(path);
-					}
-				}
+			case MessageActionKindDTO.open_resource:
+				handleOpenResource(key, action);
 				break;
-			}
 			case MessageActionKindDTO.undo:
 			case MessageActionKindDTO.revert:
 			case MessageActionKindDTO.restore: {

frontend/src/container/AIAssistant/components/ActionsSection/utils/__tests__/applyFilterPanelType.test.ts

@@ -0,0 +1,75 @@
+import { PANEL_TYPES } from 'constants/queryBuilder';
+
+import {
+	getPanelTypeForRequestType,
+	requestTypeFromActionQuery,
+} from '../applyFilterPanelType';
+
+describe('getPanelTypeForRequestType', () => {
+	it('maps scalar (grouped aggregation) to the Table view', () => {
+		expect(getPanelTypeForRequestType('scalar')).toBe(PANEL_TYPES.TABLE);
+	});
+
+	it('maps time_series to the Time Series (graph) view', () => {
+		expect(getPanelTypeForRequestType('time_series')).toBe(
+			PANEL_TYPES.TIME_SERIES,
+		);
+	});
+
+	it('maps distribution (aggregation) to the Table view', () => {
+		expect(getPanelTypeForRequestType('distribution')).toBe(PANEL_TYPES.TABLE);
+	});
+
+	it('maps raw to the List view', () => {
+		expect(getPanelTypeForRequestType('raw')).toBe(PANEL_TYPES.LIST);
+	});
+
+	it.each([undefined, null, '', 'trace', 'nonsense', 42, {}])(
+		'defaults to the List view for raw/unknown/missing requestType (%p)',
+		(value) => {
+			expect(getPanelTypeForRequestType(value)).toBe(PANEL_TYPES.LIST);
+		},
+	);
+});
+
+describe('requestTypeFromActionQuery', () => {
+	it('reads the top-level requestType envelope field', () => {
+		expect(
+			requestTypeFromActionQuery({
+				requestType: 'scalar',
+				schemaVersion: 'v5',
+				compositeQuery: { queries: [] },
+			}),
+		).toBe('scalar');
+	});
+
+	it('returns undefined when the field or query is absent', () => {
+		expect(requestTypeFromActionQuery({})).toBeUndefined();
+		expect(requestTypeFromActionQuery(null)).toBeUndefined();
+		expect(requestTypeFromActionQuery(undefined)).toBeUndefined();
+	});
+
+	it('composes with getPanelTypeForRequestType for the reported bug payload', () => {
+		// The "log count by service" apply_filter payload from issue #304 follow-up:
+		// scalar + groupBy(service.name) must open the Table view, not List.
+		const query = {
+			requestType: 'scalar',
+			schemaVersion: 'v5',
+			compositeQuery: {
+				queries: [
+					{
+						type: 'builder_query',
+						spec: {
+							signal: 'logs',
+							aggregations: [{ expression: 'count()' }],
+							groupBy: [{ name: 'service.name' }],
+						},
+					},
+				],
+			},
+		};
+		expect(getPanelTypeForRequestType(requestTypeFromActionQuery(query))).toBe(
+			PANEL_TYPES.TABLE,
+		);
+	});
+});

frontend/src/container/AIAssistant/components/ActionsSection/utils/__tests__/openSavedView.test.ts

@@ -0,0 +1,297 @@
+import {
+	ApplyFilterSignalDTO,
+	MessageActionKindDTO,
+	SavedViewEntityDTO,
+} from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
+import { getAllViews } from 'api/saveView/getAllViews';
+import { getViewById } from 'api/saveView/getViewById';
+import ROUTES from 'constants/routes';
+import { QueryParams } from 'constants/query';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { ICompositeMetricQuery } from 'types/api/alerts/compositeQuery';
+import { AllViewsProps, ViewProps } from 'types/api/saveViews/types';
+import { DataSource } from 'types/common/queryBuilder';
+import { AxiosResponse } from 'axios';
+import type { History } from 'history';
+
+import {
+	buildExplorerNavigationUrl,
+	findSavedViewInLists,
+	openSavedView,
+	openSavedViewByKey,
+} from '../openSavedView';
+import {
+	entityToDataSource,
+	isSavedViewOpenAction,
+	resolveActionEntity,
+	resolveOpenResourceType,
+	resolveResourceId,
+	resolveResourceType,
+	resolveSavedViewSourceHint,
+} from '../resolveOpenResource';
+import { resourceRoute, ResourceType } from '../resourceRoute';
+
+jest.mock('api/saveView/getAllViews');
+jest.mock('api/saveView/getViewById');
+
+jest.mock(
+	'lib/newQueryBuilder/queryBuilderMappers/mapQueryDataFromApi',
+	() => ({
+		mapQueryDataFromApi: jest.fn(() => ({
+			queryType: 'builder',
+			builder: {
+				queryData: [{ id: 'A' }],
+				queryFormulas: [],
+				queryTraceOperator: [],
+			},
+		})),
+	}),
+);
+
+const mockedGetAllViews = getAllViews as jest.MockedFunction<
+	typeof getAllViews
+>;
+const mockedGetViewById = getViewById as jest.MockedFunction<
+	typeof getViewById
+>;
+
+function makeView(id: string, sourcePage: DataSource): ViewProps {
+	return {
+		id,
+		name: `View ${id}`,
+		category: 'test',
+		createdAt: '2021-07-07T06:31:00.000Z',
+		createdBy: 'user',
+		updatedAt: '2021-07-07T06:33:00.000Z',
+		updatedBy: 'user',
+		sourcePage,
+		tags: [],
+		extraData: '',
+		compositeQuery: {
+			panelType: PANEL_TYPES.LIST,
+		} as ICompositeMetricQuery,
+	};
+}
+
+function mockViewsResponse(views: ViewProps[]): AxiosResponse<AllViewsProps> {
+	return {
+		data: { status: 'success', data: views },
+	} as AxiosResponse<AllViewsProps>;
+}
+
+function mockViewByIdResponse(
+	view: ViewProps,
+): AxiosResponse<{ status: string; data: ViewProps }> {
+	return {
+		data: { status: 'success', data: view },
+	} as AxiosResponse<{ status: string; data: ViewProps }>;
+}
+
+describe('resourceRoute', () => {
+	it('returns null for saved_view so async navigation is used', () => {
+		expect(resourceRoute(ResourceType.saved_view, 'view-123')).toBeNull();
+	});
+
+	it('routes channels to the edit page', () => {
+		expect(resourceRoute(ResourceType.channel, 'channel-uuid-1')).toBe(
+			'/settings/channels/edit/channel-uuid-1',
+		);
+	});
+});
+
+describe('resolveOpenResource', () => {
+	it('reads entity from the action envelope', () => {
+		expect(
+			resolveActionEntity({
+				kind: MessageActionKindDTO.open_resource,
+				label: 'Open view',
+				entity: SavedViewEntityDTO.traces,
+			}),
+		).toBe(SavedViewEntityDTO.traces);
+	});
+
+	it('reads resource id from input.viewKey', () => {
+		expect(
+			resolveResourceId({
+				kind: MessageActionKindDTO.open_resource,
+				label: 'Open view',
+				input: { viewKey: 'abc-123' },
+			}),
+		).toBe('abc-123');
+	});
+
+	it('maps entity values to explorer data sources', () => {
+		expect(entityToDataSource('logs')).toBe(DataSource.LOGS);
+		expect(entityToDataSource('logs_explorer')).toBe(DataSource.LOGS);
+		expect(entityToDataSource('traces')).toBe(DataSource.TRACES);
+	});
+
+	it('prefers entity over signal for saved-view source hints', () => {
+		expect(
+			resolveSavedViewSourceHint({
+				kind: MessageActionKindDTO.open_resource,
+				label: 'Open view',
+				entity: SavedViewEntityDTO.traces,
+				signal: ApplyFilterSignalDTO.logs,
+			}),
+		).toBe(DataSource.TRACES);
+	});
+
+	it('falls back to signal when entity is absent', () => {
+		expect(
+			resolveSavedViewSourceHint({
+				kind: MessageActionKindDTO.open_resource,
+				label: 'Open view',
+				signal: ApplyFilterSignalDTO.metrics,
+			}),
+		).toBe(DataSource.METRICS);
+	});
+
+	it('normalises saved-view resource types', () => {
+		expect(
+			resolveResourceType({
+				kind: MessageActionKindDTO.open_resource,
+				label: 'Open view',
+				resourceType: 'saved-view',
+			}),
+		).toBe(ResourceType.saved_view);
+	});
+
+	it('detects open-view actions from label when id is present in input', () => {
+		expect(
+			isSavedViewOpenAction({
+				kind: MessageActionKindDTO.open_resource,
+				label: 'Open view',
+				input: { viewId: 'view-1' },
+			}),
+		).toBe(true);
+	});
+
+	it('resolves channel type from notification_channel alias', () => {
+		expect(
+			resolveResourceType({
+				kind: MessageActionKindDTO.open_resource,
+				label: 'Open channel',
+				resourceType: 'notification_channel',
+			}),
+		).toBe(ResourceType.channel);
+	});
+
+	it('infers channel type from Open channel label when resourceId is present', () => {
+		expect(
+			resolveOpenResourceType({
+				kind: MessageActionKindDTO.open_resource,
+				label: 'Open channel',
+				resourceId: 'channel-1',
+			}),
+		).toBe(ResourceType.channel);
+	});
+});
+
+describe('findSavedViewInLists', () => {
+	beforeEach(() => {
+		mockedGetAllViews.mockReset();
+	});
+
+	it('loads only the hinted source when entity is provided', async () => {
+		const tracesView = makeView('view-traces', DataSource.TRACES);
+		mockedGetAllViews.mockResolvedValueOnce(mockViewsResponse([tracesView]));
+
+		const result = await findSavedViewInLists('view-traces', DataSource.TRACES);
+
+		expect(result).toStrictEqual(tracesView);
+		expect(mockedGetAllViews).toHaveBeenCalledTimes(1);
+		expect(mockedGetAllViews).toHaveBeenCalledWith(DataSource.TRACES);
+	});
+});
+
+describe('buildExplorerNavigationUrl', () => {
+	it('encodes composite query and view selectors', () => {
+		const url = buildExplorerNavigationUrl(
+			ROUTES.LOGS_EXPLORER,
+			{ queryType: 'builder' } as never,
+			{
+				[QueryParams.panelTypes]: PANEL_TYPES.LIST,
+				[QueryParams.viewName]: 'My view',
+				[QueryParams.viewKey]: 'view-1',
+			},
+		);
+
+		expect(url).toContain(ROUTES.LOGS_EXPLORER);
+		expect(url).toContain(`${QueryParams.compositeQuery}=`);
+		expect(url).toContain(`${QueryParams.viewKey}=`);
+	});
+
+	// Regression guard for the apply_filter view bug: the panel type must land
+	// on the URL JSON-encoded the way `useGetPanelTypesQueryParam` reads it
+	// (`JSON.parse` of the param), i.e. as the quoted string `"table"` ->
+	// `panelTypes=%22table%22`. Without this the explorer falls back to LIST.
+	it('JSON-encodes panelTypes so the explorer opens the right view', () => {
+		const url = buildExplorerNavigationUrl(
+			ROUTES.LOGS_EXPLORER,
+			{ queryType: 'builder' } as never,
+			{ [QueryParams.panelTypes]: PANEL_TYPES.TABLE },
+		);
+
+		expect(url).toContain(`${QueryParams.panelTypes}=%22table%22`);
+	});
+});
+
+describe('openSavedView', () => {
+	it('navigates with history.push and view query params', () => {
+		const push = jest.fn();
+		const history = { push } as unknown as History;
+		const view = makeView('view-logs', DataSource.LOGS);
+
+		openSavedView(view, history);
+
+		expect(push).toHaveBeenCalledTimes(1);
+		const pushedUrl = push.mock.calls[0][0] as string;
+		expect(pushedUrl).toContain(ROUTES.LOGS_EXPLORER);
+		expect(pushedUrl).toContain(QueryParams.viewKey);
+	});
+});
+
+describe('openSavedViewByKey', () => {
+	beforeEach(() => {
+		mockedGetAllViews.mockReset();
+		mockedGetViewById.mockReset();
+	});
+
+	it('prefers the direct view lookup endpoint', async () => {
+		const view = makeView('view-logs', DataSource.LOGS);
+		mockedGetViewById.mockResolvedValueOnce(mockViewByIdResponse(view));
+		const push = jest.fn();
+		const history = { push } as unknown as History;
+
+		await openSavedViewByKey('view-logs', DataSource.LOGS, history);
+
+		expect(mockedGetViewById).toHaveBeenCalledWith('view-logs');
+		expect(mockedGetAllViews).not.toHaveBeenCalled();
+		expect(push).toHaveBeenCalled();
+	});
+
+	it('falls back to list probing when direct lookup fails', async () => {
+		const view = makeView('view-traces', DataSource.TRACES);
+		mockedGetViewById.mockRejectedValueOnce(new Error('not found'));
+		mockedGetAllViews.mockResolvedValueOnce(mockViewsResponse([view]));
+		const push = jest.fn();
+		const history = { push } as unknown as History;
+
+		await openSavedViewByKey('view-traces', DataSource.TRACES, history);
+
+		expect(mockedGetAllViews).toHaveBeenCalledWith(DataSource.TRACES);
+		expect(push).toHaveBeenCalled();
+	});
+
+	it('throws when the saved view does not exist', async () => {
+		mockedGetViewById.mockRejectedValueOnce(new Error('not found'));
+		mockedGetAllViews.mockResolvedValue(mockViewsResponse([]));
+
+		await expect(
+			openSavedViewByKey('missing', DataSource.LOGS, {
+				push: jest.fn(),
+			} as unknown as History),
+		).rejects.toThrow('Saved view not found');
+	});
+});

frontend/src/container/AIAssistant/components/ActionsSection/utils/applyFilterPanelType.ts

@@ -0,0 +1,46 @@
+import { REQUEST_TYPES } from 'api/v5/queryRange/constants';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { RequestType } from 'types/api/v5/queryRange';
+
+/**
+ * Maps an apply_filter `query.requestType` to the explorer panel type so the
+ * Explorer opens in the view the query implies:
+ *
+ *   - `scalar`       -> Table        (grouped aggregation, e.g. "count by service")
+ *   - `distribution` -> Table        (aggregation; Logs/Traces have no histogram view)
+ *   - `time_series`  -> Time Series  (graph)
+ *   - `raw` / other  -> List         (raw rows) [default]
+ *
+ * `trace` and the empty request type fall through to the List default on
+ * purpose — they are raw, ungrouped result sets.
+ *
+ * The agent emits `requestType` on the request envelope of `action.query`. It
+ * must be read off the raw action query *before* `toUrlCompositeQuery` maps the
+ * inner `compositeQuery` (that mapper keeps only the builder queries and drops
+ * the envelope). Without an explicit `panelTypes` URL param the Explorer falls
+ * back to `PANEL_TYPES.LIST` (see `useGetPanelTypesQueryParam`), so a grouped
+ * "count by service" query renders as a raw log list instead of a table.
+ */
+const REQUEST_TYPE_TO_PANEL_TYPE: Partial<Record<RequestType, PANEL_TYPES>> = {
+	[REQUEST_TYPES.SCALAR]: PANEL_TYPES.TABLE,
+	[REQUEST_TYPES.DISTRIBUTION]: PANEL_TYPES.TABLE,
+	[REQUEST_TYPES.TIME_SERIES]: PANEL_TYPES.TIME_SERIES,
+	[REQUEST_TYPES.RAW]: PANEL_TYPES.LIST,
+};
+
+export function getPanelTypeForRequestType(requestType: unknown): PANEL_TYPES {
+	if (typeof requestType === 'string') {
+		const mapped = REQUEST_TYPE_TO_PANEL_TYPE[requestType as RequestType];
+		if (mapped) {
+			return mapped;
+		}
+	}
+	return PANEL_TYPES.LIST;
+}
+
+/** Reads the `requestType` envelope field off a raw apply_filter query payload. */
+export function requestTypeFromActionQuery(
+	query: Record<string, unknown> | null | undefined,
+): unknown {
+	return query?.requestType;
+}

frontend/src/container/AIAssistant/components/ActionsSection/utils/openSavedView.ts

@@ -0,0 +1,117 @@
+import { getAllViews } from 'api/saveView/getAllViews';
+import { getViewById } from 'api/saveView/getViewById';
+import { QueryParams } from 'constants/query';
+import { PANEL_TYPES } from 'constants/queryBuilder';
+import { mapQueryDataFromApi } from 'lib/newQueryBuilder/queryBuilderMappers/mapQueryDataFromApi';
+import { SOURCEPAGE_VS_ROUTES } from 'pages/SaveView/constants';
+import { ViewProps } from 'types/api/saveViews/types';
+import { DataSource } from 'types/common/queryBuilder';
+import { Query } from 'types/api/queryBuilder/queryBuilderData';
+import { History } from 'history';
+
+type SavedViewSourceHint = DataSource | 'meter';
+
+const DEFAULT_PROBE_SOURCES: SavedViewSourceHint[] = [
+	DataSource.LOGS,
+	DataSource.TRACES,
+	DataSource.METRICS,
+];
+
+export async function findSavedViewInLists(
+	viewKey: string,
+	sourceHint?: SavedViewSourceHint | null,
+): Promise<ViewProps | null> {
+	const sources = sourceHint ? [sourceHint] : DEFAULT_PROBE_SOURCES;
+
+	for (const source of sources) {
+		try {
+			const response = await getAllViews(source);
+			const match = response.data.data.find((view) => view.id === viewKey);
+			if (match) {
+				return match;
+			}
+		} catch {
+			// Probe the next source page when no entity hint is provided.
+		}
+	}
+
+	return null;
+}
+
+async function loadSavedView(
+	viewKey: string,
+	sourceHint?: SavedViewSourceHint | null,
+): Promise<ViewProps> {
+	try {
+		const response = await getViewById(viewKey);
+		if (response.data?.data) {
+			return response.data.data;
+		}
+	} catch {
+		// Fall back to list probing when the direct lookup fails.
+	}
+
+	const fromList = await findSavedViewInLists(viewKey, sourceHint);
+	if (fromList) {
+		return fromList;
+	}
+
+	throw new Error('Saved view not found');
+}
+
+export function explorerRouteForSourcePage(
+	sourcePage: DataSource | string,
+): (typeof SOURCEPAGE_VS_ROUTES)[keyof typeof SOURCEPAGE_VS_ROUTES] | null {
+	return SOURCEPAGE_VS_ROUTES[sourcePage] ?? null;
+}
+
+/**
+ * Builds an explorer URL the same way `redirectWithQueryBuilderData` does —
+ * without inheriting stale query params from the current page's `urlQuery`.
+ */
+export function buildExplorerNavigationUrl(
+	route: string,
+	query: Query,
+	searchParams: Record<string, unknown>,
+): string {
+	const params = new URLSearchParams();
+	params.set(
+		QueryParams.compositeQuery,
+		encodeURIComponent(JSON.stringify(query)),
+	);
+	Object.entries(searchParams).forEach(([key, value]) => {
+		params.set(key, JSON.stringify(value));
+	});
+	return `${route}?${params.toString()}`;
+}
+
+export function openSavedView(view: ViewProps, history: History): void {
+	const route = explorerRouteForSourcePage(view.sourcePage);
+	if (!route) {
+		throw new Error('Unsupported saved view source');
+	}
+
+	if (!view.compositeQuery) {
+		throw new Error('Saved view is missing query data');
+	}
+
+	const query = mapQueryDataFromApi(view.compositeQuery);
+	const url = buildExplorerNavigationUrl(route, query, {
+		[QueryParams.panelTypes]: view.compositeQuery.panelType as PANEL_TYPES,
+		[QueryParams.viewName]: view.name,
+		[QueryParams.viewKey]: view.id,
+	});
+	history.push(url);
+}
+
+export async function openSavedViewByKey(
+	viewKey: string,
+	sourceHint: SavedViewSourceHint | null | undefined,
+	history: History,
+): Promise<void> {
+	const view = await loadSavedView(viewKey, sourceHint);
+	openSavedView(view, history);
+}
+
+/** @deprecated Use findSavedViewInLists — kept for tests. */
+export const findSavedView = findSavedViewInLists;

frontend/src/container/AIAssistant/components/ActionsSection/utils/resolveOpenResource.ts

@@ -0,0 +1,203 @@
+import type { MessageActionDTO } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
+import {
+	ApplyFilterSignalDTO,
+	SavedViewEntityDTO,
+} from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
+import { DataSource } from 'types/common/queryBuilder';
+
+import { ResourceType } from './resourceRoute';
+
+function readString(value: unknown): string | null {
+	if (typeof value !== 'string') {
+		return null;
+	}
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+
+/** Normalises backend resource-type strings to the taxonomy used in the UI. */
+export function normalizeResourceType(
+	resourceType: string | null | undefined,
+): string | null {
+	if (!resourceType) {
+		return null;
+	}
+
+	const normalized = resourceType.trim().toLowerCase().replace(/-/g, '_');
+	if (normalized === 'savedview') {
+		return ResourceType.saved_view;
+	}
+	if (
+		normalized === 'notification_channel' ||
+		normalized === 'notificationchannel'
+	) {
+		return ResourceType.channel;
+	}
+
+	return normalized;
+}
+
+/** Reads a resource type from the action envelope or its `input` payload. */
+export function resolveResourceType(action: MessageActionDTO): string | null {
+	const direct = normalizeResourceType(action.resourceType);
+	if (direct) {
+		return direct;
+	}
+
+	const input = action.input;
+	if (!input) {
+		return null;
+	}
+
+	return (
+		normalizeResourceType(readString(input.resourceType)) ??
+		normalizeResourceType(readString(input.type))
+	);
+}
+
+/**
+ * Resolves the resource type for an `open_resource` action, including label-based
+ * fallbacks when the backend only sends a display label + id.
+ */
+export function resolveOpenResourceType(
+	action: MessageActionDTO,
+): string | null {
+	const fromFields = resolveResourceType(action);
+	if (fromFields) {
+		return fromFields;
+	}
+
+	if (/open\s+channel/i.test(action.label) && resolveResourceId(action)) {
+		return ResourceType.channel;
+	}
+
+	return null;
+}
+
+/** Reads a resource id from `resourceId` or common `input` keys. */
+export function resolveResourceId(action: MessageActionDTO): string | null {
+	const direct = readString(action.resourceId);
+	if (direct) {
+		return direct;
+	}
+
+	const input = action.input;
+	if (!input) {
+		return null;
+	}
+
+	for (const key of [
+		'resourceId',
+		'viewId',
+		'viewKey',
+		'channelId',
+		'id',
+	] as const) {
+		const value = readString(input[key]);
+		if (value) {
+			return value;
+		}
+	}
+
+	return null;
+}
+
+/** Reads `entity` from the action envelope or its `input` payload. */
+export function resolveActionEntity(
+	action: MessageActionDTO,
+): SavedViewEntityDTO | null {
+	if (action.entity) {
+		return action.entity;
+	}
+
+	const fromInput = readString(action.input?.entity);
+	if (!fromInput) {
+		return null;
+	}
+
+	return normalizeToSavedViewEntity(fromInput);
+}
+
+function normalizeToSavedViewEntity(value: string): SavedViewEntityDTO | null {
+	const source = entityToDataSource(value);
+	switch (source) {
+		case DataSource.LOGS:
+			return SavedViewEntityDTO.logs;
+		case DataSource.TRACES:
+			return SavedViewEntityDTO.traces;
+		case DataSource.METRICS:
+			return SavedViewEntityDTO.metrics;
+		case 'meter':
+			return SavedViewEntityDTO.meter;
+		default:
+			return null;
+	}
+}
+
+/**
+ * Maps an action `entity` to an explorer `DataSource` for saved-view lookups.
+ * Accepts both short (`logs`) and taxonomy (`logs_explorer`) values.
+ */
+export function entityToDataSource(
+	entity: SavedViewEntityDTO | string,
+): DataSource | 'meter' | null {
+	const normalized = entity.trim().toLowerCase().replace(/-/g, '_');
+
+	switch (normalized) {
+		case SavedViewEntityDTO.logs:
+		case ResourceType.logs_explorer:
+			return DataSource.LOGS;
+		case SavedViewEntityDTO.traces:
+		case ResourceType.traces_explorer:
+			return DataSource.TRACES;
+		case SavedViewEntityDTO.metrics:
+		case ResourceType.metrics_explorer:
+			return DataSource.METRICS;
+		case SavedViewEntityDTO.meter:
+			return 'meter';
+		default:
+			return null;
+	}
+}
+
+/**
+ * Picks which explorer source page to search when resolving a saved view.
+ * Prefers `entity` (open_resource); falls back to `signal` only for legacy payloads.
+ */
+export function resolveSavedViewSourceHint(
+	action: MessageActionDTO,
+): DataSource | 'meter' | null {
+	const entity = resolveActionEntity(action);
+	if (entity) {
+		const fromEntity = entityToDataSource(entity);
+		if (fromEntity) {
+			return fromEntity;
+		}
+	}
+
+	if (action.signal) {
+		switch (action.signal) {
+			case ApplyFilterSignalDTO.logs:
+				return DataSource.LOGS;
+			case ApplyFilterSignalDTO.traces:
+				return DataSource.TRACES;
+			case ApplyFilterSignalDTO.metrics:
+				return DataSource.METRICS;
+			default: {
+				const _exhaustive: never = action.signal;
+				return _exhaustive;
+			}
+		}
+	}
+
+	return null;
+}
+
+export function isSavedViewOpenAction(action: MessageActionDTO): boolean {
+	if (resolveResourceType(action) === ResourceType.saved_view) {
+		return true;
+	}
+
+	// Defensive: some agent payloads only set a human label + id in `input`.
+	return /open\s+view/i.test(action.label) && resolveResourceId(action) !== null;
+}

frontend/src/container/AIAssistant/components/ActionsSection/utils/resourceRoute.ts

@@ -0,0 +1,50 @@
+import ROUTES from 'constants/routes';
+import { QueryParams } from 'constants/query';
+
+/**
+ * Resource-type strings the backend uses for `open_resource` and rollback
+ * actions. Centralized here so route/module lookups stay in sync.
+ */
+export const ResourceType = {
+	dashboard: 'dashboard',
+	alert: 'alert',
+	service: 'service',
+	channel: 'channel',
+	saved_view: 'saved_view',
+	logs_explorer: 'logs_explorer',
+	traces_explorer: 'traces_explorer',
+	metrics_explorer: 'metrics_explorer',
+} as const;
+
+/**
+ * Resolves an `open_resource` action to an in-app route for synchronous
+ * navigation. Returns `null` for `saved_view` — callers must load the view
+ * by id and navigate with query-builder state instead.
+ */
+export function resourceRoute(
+	resourceType: string,
+	resourceId: string,
+): string | null {
+	switch (resourceType) {
+		case ResourceType.dashboard:
+			return ROUTES.DASHBOARD.replace(':dashboardId', resourceId);
+		case ResourceType.alert: {
+			const params = new URLSearchParams({ [QueryParams.ruleId]: resourceId });
+			return `${ROUTES.EDIT_ALERTS}?${params.toString()}`;
+		}
+		case ResourceType.service:
+			return ROUTES.SERVICE_METRICS.replace(':servicename', resourceId);
+		case ResourceType.channel:
+			return ROUTES.CHANNELS_EDIT.replace(':channelId', resourceId);
+		case ResourceType.saved_view:
+			return null;
+		case ResourceType.logs_explorer:
+			return ROUTES.LOGS_EXPLORER;
+		case ResourceType.traces_explorer:
+			return ROUTES.TRACES_EXPLORER;
+		case ResourceType.metrics_explorer:
+			return ROUTES.METRICS_EXPLORER_EXPLORER;
+		default:
+			return null;
+	}
+}

frontend/src/container/AIAssistant/components/ChatInput/ChatInput.tsx

@@ -101,6 +101,8 @@ function autoContextLabel(ctx: MessageContext): string {
 			return 'Panel (fullscreen)';
 		case 'dashboard_list':
 			return 'Dashboards';
+		case 'alert_detail':
+			return 'Current alert';
 		case 'alert_edit':
 			return 'Editing alert';
 		case 'alert_new':

frontend/src/container/AIAssistant/components/MarkdownExternalLink/MarkdownExternalLink.tsx

@@ -0,0 +1,26 @@
+import type { ComponentProps } from 'react';
+
+type MarkdownExternalLinkProps = ComponentProps<'a'> & {
+	// react-markdown passes `node` — accept and ignore it
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	node?: any;
+};
+
+export default function MarkdownExternalLink({
+	href,
+	children,
+	node: _node,
+	...props
+}: MarkdownExternalLinkProps): JSX.Element {
+	return (
+		<a
+			href={href}
+			target="_blank"
+			rel="noopener noreferrer"
+			data-testid="ai-markdown-link"
+			{...props}
+		>
+			{children}
+		</a>
+	);
+}

frontend/src/container/AIAssistant/components/MessageBubble/MessageBubble.tsx

@@ -11,6 +11,7 @@ import { Message, MessageBlock } from '../../types';
 import ActionsSection from '../ActionsSection';
 import ActivityGroup, { ActivityItem } from '../ActivityGroup';
 import { RichCodeBlock } from '../blocks';
+import MarkdownExternalLink from '../MarkdownExternalLink/MarkdownExternalLink';
 import { MessageContext } from '../MessageContext';
 import MessageFeedback from '../MessageFeedback';
 import UserMessageActions from '../UserMessageActions';
@@ -37,7 +38,11 @@ function SmartPre({ children }: { children?: React.ReactNode }): JSX.Element {
 }
 
 const MD_PLUGINS = [remarkGfm];
-const MD_COMPONENTS = { code: RichCodeBlock, pre: SmartPre };
+const MD_COMPONENTS = {
+	code: RichCodeBlock,
+	pre: SmartPre,
+	a: MarkdownExternalLink,
+};
 
 type RenderGroup =
 	| { kind: 'text'; id: string; content: string }

frontend/src/container/AIAssistant/components/MessageFeedback/MessageFeedback.module.scss

@@ -50,7 +50,7 @@
 	font-size: 10px;
 	color: var(--l3-foreground);
 	white-space: nowrap;
-	padding-left: 2px;
+	padding-left: 8px;
 	border-left: 1px solid var(--l2-border);
 }
 

frontend/src/container/AIAssistant/components/StreamingMessage/StreamingMessage.tsx

@@ -13,6 +13,7 @@ import { StreamingEventItem } from '../../types';
 import ActivityGroup, { ActivityItem } from '../ActivityGroup';
 import ApprovalCard from '../ApprovalCard';
 import { RichCodeBlock } from '../blocks';
+import MarkdownExternalLink from '../MarkdownExternalLink/MarkdownExternalLink';
 import ClarificationForm from '../ClarificationForm';
 
 import messageStyles from '../MessageBubble/MessageBubble.module.scss';
@@ -30,7 +31,11 @@ function SmartPre({ children }: { children?: React.ReactNode }): JSX.Element {
 }
 
 const MD_PLUGINS = [remarkGfm];
-const MD_COMPONENTS = { code: RichCodeBlock, pre: SmartPre };
+const MD_COMPONENTS = {
+	code: RichCodeBlock,
+	pre: SmartPre,
+	a: MarkdownExternalLink,
+};
 
 type RenderGroup =
 	| { kind: 'text'; id: string; content: string }

frontend/src/container/AIAssistant/getAutoContexts.ts

@@ -99,6 +99,30 @@ export function getAutoContexts(
 
 	// ── Alerts ────────────────────────────────────────────────────────────────
 
+	// Alert detail (overview / per-rule history) — `/alerts/overview?ruleId=…`
+	// or `/alerts/history?ruleId=…`. Mirrors dashboard_detail: resourceId is the
+	// rule id and shared metadata carries the URL time range when present.
+	if (
+		matchPath(pathname, { path: ROUTES.ALERT_OVERVIEW, exact: true }) ||
+		matchPath(pathname, { path: ROUTES.ALERT_HISTORY, exact: true })
+	) {
+		const ruleId = params.get(QueryParams.ruleId);
+		if (ruleId) {
+			return [
+				{
+					source: 'auto',
+					type: 'alert',
+					resourceId: ruleId,
+					metadata: {
+						page: 'alert_detail',
+						ruleId,
+						...sharedMetadata,
+					},
+				},
+			];
+		}
+	}
+
 	// Alert edit — `/alerts/edit?ruleId=…`.
 	if (matchPath(pathname, { path: ROUTES.EDIT_ALERTS, exact: true })) {
 		const ruleId = params.get(QueryParams.ruleId);
@@ -108,7 +132,7 @@ export function getAutoContexts(
 					source: 'auto',
 					type: 'alert',
 					resourceId: ruleId,
-					metadata: { page: 'alert_edit' },
+					metadata: { page: 'alert_edit', ruleId },
 				},
 			];
 		}
@@ -125,6 +149,7 @@ export function getAutoContexts(
 		];
 	}
 
+	// Triggered-alerts index — `/alerts/history` without a rule id.
 	if (matchPath(pathname, { path: ROUTES.ALERT_HISTORY, exact: true })) {
 		return [
 			{

frontend/src/container/AIAssistant/store/useAIAssistantStore.ts

@@ -1,12 +1,10 @@
 /* eslint-disable sonarjs/cognitive-complexity */
-import axios from 'axios';
 import { v4 as uuidv4 } from 'uuid';
 import { create } from 'zustand';
 import { persist } from 'zustand/middleware';
 import { immer } from 'zustand/middleware/immer';
 
 import type {
-	ErrorResponseDTO,
 	MessageActionDTO,
 	MessageSummaryDTOBlocksAnyOfItem,
 } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
@@ -37,6 +35,7 @@ import {
 	MessageBlock,
 	MessageRole,
 } from '../types';
+import { resolveAssistantErrorMessage } from '../utils/resolveAssistantErrorMessage';
 
 // ---------------------------------------------------------------------------
 // Types used by module-level helpers
@@ -399,6 +398,7 @@ async function runStreamingLoop(
 			}
 			throw Object.assign(new Error(event.error.message), {
 				retryAction: event.retryAction,
+				code: event.error.code,
 			});
 		} else if (event.type === 'conversation' && event.title) {
 			set((s) => {
@@ -484,36 +484,6 @@ function hasPendingInput(conversationId: string, get: StoreGetter): boolean {
 	return Boolean(stream?.pendingApproval || stream?.pendingClarification);
 }
 
-function parseErrorBody(value: unknown): string | null {
-	if (typeof value === 'string') {
-		try {
-			return parseErrorBody(JSON.parse(value));
-		} catch {
-			return null;
-		}
-	}
-	const message = (value as ErrorResponseDTO | undefined)?.error?.message;
-	return typeof message === 'string' && message.length > 0 ? message : null;
-}
-
-/**
- * Returns the backend's `error.message` when `err` is a 429 axios response
- * (typically from the threads API surface — createThread, sendMessage, approve,
- * clarify, regenerate). Returns null for any other error so callers fall
- * through to their generic copy.
- */
-function rateLimitMessage(err: unknown): string | null {
-	if (axios.isAxiosError(err) && err.response?.status === 429) {
-		return parseErrorBody(err.response.data);
-	}
-	return null;
-}
-
-/**
- * Commits an error message and removes the stream entry. When `isRateLimit`
- * is true, the committed message is flagged so the feedback/regenerate bar
- * is hidden — clicking regenerate would just 429 again.
- */
 function finalizeStreamingError(
 	conversationId: string,
 	errorContent: string,
@@ -1174,14 +1144,11 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 						return;
 					}
 					console.error('[AIAssistant] sendMessage failed:', err);
-					const rateLimit = rateLimitMessage(err);
-					finalizeStreamingError(
-						convId,
-						rateLimit ??
-							'Something went wrong while fetching the response. Please try again.',
-						set,
-						rateLimit !== null,
+					const { message, isRateLimit } = resolveAssistantErrorMessage(
+						err,
+						'Something went wrong while fetching the response. Please try again.',
 					);
+					finalizeStreamingError(convId, message, set, isRateLimit);
 				}
 			},
 
@@ -1214,14 +1181,11 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 						return;
 					}
 					console.error('[AIAssistant] approveAction failed:', err);
-					const rateLimit = rateLimitMessage(err);
-					finalizeStreamingError(
-						conversationId,
-						rateLimit ??
-							'Something went wrong while processing the approval. Please try again.',
-						set,
-						rateLimit !== null,
+					const { message, isRateLimit } = resolveAssistantErrorMessage(
+						err,
+						'Something went wrong while processing the approval. Please try again.',
 					);
+					finalizeStreamingError(conversationId, message, set, isRateLimit);
 				}
 			},
 
@@ -1296,14 +1260,11 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 						return;
 					}
 					console.error('[AIAssistant] regenerateAssistantMessage failed:', err);
-					const rateLimit = rateLimitMessage(err);
-					finalizeStreamingError(
-						conversationId,
-						rateLimit ??
-							'Something went wrong while regenerating the response. Please try again.',
-						set,
-						rateLimit !== null,
+					const { message, isRateLimit } = resolveAssistantErrorMessage(
+						err,
+						'Something went wrong while regenerating the response. Please try again.',
 					);
+					finalizeStreamingError(conversationId, message, set, isRateLimit);
 				}
 			},
 
@@ -1365,14 +1326,11 @@ export const useAIAssistantStore = create<AIAssistantStore>()(
 						return;
 					}
 					console.error('[AIAssistant] submitClarification failed:', err);
-					const rateLimit = rateLimitMessage(err);
-					finalizeStreamingError(
-						conversationId,
-						rateLimit ??
-							'Something went wrong while processing your answers. Please try again.',
-						set,
-						rateLimit !== null,
+					const { message, isRateLimit } = resolveAssistantErrorMessage(
+						err,
+						'Something went wrong while processing your answers. Please try again.',
 					);
+					finalizeStreamingError(conversationId, message, set, isRateLimit);
 				}
 			},
 		})),

frontend/src/container/AIAssistant/utils/__tests__/resolveAssistantErrorMessage.test.ts

@@ -0,0 +1,91 @@
+import { AxiosError } from 'axios';
+import { ErrorCodeDTO } from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
+
+import { resolveAssistantErrorMessage } from '../resolveAssistantErrorMessage';
+
+const FALLBACK = 'Something went wrong. Please try again.';
+
+describe('resolveAssistantErrorMessage', () => {
+	it('returns backend message for a known error code', () => {
+		const err = new AxiosError('Request failed');
+		err.response = {
+			status: 400,
+			data: {
+				error: {
+					code: ErrorCodeDTO.thread_busy,
+					message: 'This thread is busy. Try again shortly.',
+				},
+			},
+		} as AxiosError['response'];
+
+		expect(resolveAssistantErrorMessage(err, FALLBACK)).toStrictEqual({
+			message: 'This thread is busy. Try again shortly.',
+			isRateLimit: false,
+		});
+	});
+
+	it('falls back when error code is not in ErrorCodeDTO', () => {
+		const err = new AxiosError('Request failed');
+		err.response = {
+			status: 400,
+			data: {
+				error: {
+					code: 'future_unknown_code',
+					message: 'Backend-only message',
+				},
+			},
+		} as AxiosError['response'];
+
+		expect(resolveAssistantErrorMessage(err, FALLBACK)).toStrictEqual({
+			message: FALLBACK,
+			isRateLimit: false,
+		});
+	});
+
+	it('marks HTTP 429 responses as rate limited', () => {
+		const err = new AxiosError('Too many requests');
+		err.response = {
+			status: 429,
+			data: {
+				error: {
+					code: ErrorCodeDTO.hourly_message_limit,
+					message: 'Hourly limit reached.',
+				},
+			},
+		} as AxiosError['response'];
+
+		expect(resolveAssistantErrorMessage(err, FALLBACK)).toStrictEqual({
+			message: 'Hourly limit reached.',
+			isRateLimit: true,
+		});
+	});
+
+	it('uses backend message for known SSE rate-limit error codes', () => {
+		const err = Object.assign(new Error('Daily token limit exceeded.'), {
+			code: ErrorCodeDTO.daily_token_limit,
+		});
+
+		expect(resolveAssistantErrorMessage(err, FALLBACK)).toStrictEqual({
+			message: 'Daily token limit exceeded.',
+			isRateLimit: true,
+		});
+	});
+
+	it('marks 429 as rate limited even when error code is unknown', () => {
+		const err = new AxiosError('Too many requests');
+		err.response = {
+			status: 429,
+			data: {
+				error: {
+					code: 'future_unknown_code',
+					message: 'Too many requests',
+				},
+			},
+		} as AxiosError['response'];
+
+		expect(resolveAssistantErrorMessage(err, FALLBACK)).toStrictEqual({
+			message: FALLBACK,
+			isRateLimit: true,
+		});
+	});
+});

frontend/src/container/AIAssistant/utils/resolveAssistantErrorMessage.ts

@@ -0,0 +1,71 @@
+import { isAxiosError } from 'axios';
+import {
+	ErrorCodeDTO,
+	type ErrorBodyDTO,
+	type ErrorResponseDTO,
+} from 'api/ai-assistant/sigNozAIAssistantAPI.schemas';
+
+export interface AssistantErrorResolution {
+	message: string;
+	isRateLimit: boolean;
+}
+
+function isErrorCodeDTO(code: string | undefined): code is ErrorCodeDTO {
+	return (
+		code !== undefined && (Object.values(ErrorCodeDTO) as string[]).includes(code)
+	);
+}
+
+const RATE_LIMIT_ERROR_CODES = new Set<ErrorCodeDTO>([
+	ErrorCodeDTO.rate_limit_override_exceeds_ceiling,
+	ErrorCodeDTO.thread_message_limit,
+	ErrorCodeDTO.connection_limit_exceeded,
+	ErrorCodeDTO.hourly_message_limit,
+	ErrorCodeDTO.daily_message_limit,
+	ErrorCodeDTO.daily_token_limit,
+	ErrorCodeDTO.daily_cost_limit,
+	ErrorCodeDTO.budget_exceeded,
+]);
+
+function isRateLimitError(code: string | undefined, err: unknown): boolean {
+	if (isAxiosError(err) && err.response?.status === 429) {
+		return true;
+	}
+
+	return isErrorCodeDTO(code) && RATE_LIMIT_ERROR_CODES.has(code);
+}
+
+function getErrorBody(err: unknown): ErrorBodyDTO | null {
+	if (isAxiosError(err)) {
+		return (err.response?.data as ErrorResponseDTO | undefined)?.error ?? null;
+	}
+
+	const code = (err as { code?: string } | undefined)?.code;
+	const message = err instanceof Error ? err.message : undefined;
+	if (!code || !message) {
+		return null;
+	}
+
+	return { code: code as ErrorCodeDTO, message };
+}
+
+/**
+ * Uses `error.message` when `error.code` is a known `ErrorCodeDTO`;
+ * otherwise returns `fallback`.
+ */
+export function resolveAssistantErrorMessage(
+	err: unknown,
+	fallback: string,
+): AssistantErrorResolution {
+	const body = getErrorBody(err);
+	const isRateLimit = isRateLimitError(body?.code, err);
+
+	if (body && isErrorCodeDTO(body.code) && body.message.trim()) {
+		return {
+			message: body.message.trim(),
+			isRateLimit,
+		};
+	}
+
+	return { message: fallback, isRateLimit: Boolean(isRateLimit) };
+}

frontend/src/container/CreateAlertRule/index.tsx

@@ -11,7 +11,6 @@ import CreateAlertV2 from 'container/CreateAlertV2';
 import FormAlertRules, { AlertDetectionTypes } from 'container/FormAlertRules';
 import DateTimeSelector from 'container/TopNav/DateTimeSelectionV2';
 import { useGetCompositeQueryParam } from 'hooks/queryBuilder/useGetCompositeQueryParam';
-import useReducedMotion from 'hooks/useReducedMotion';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { AlertListTabs } from 'pages/AlertList/types';
@@ -27,7 +26,6 @@ import './CreateAlertRule.styles.scss';
 
 function CreateRules(): JSX.Element {
 	const [formInstance] = Form.useForm();
-	const prefersReducedMotion = useReducedMotion();
 	const compositeQuery = useGetCompositeQueryParam();
 	const queryParams = useUrlQuery();
 	const { safeNavigate } = useSafeNavigate();
@@ -43,7 +41,7 @@ function CreateRules(): JSX.Element {
 
 	useEffect(() => {
 		if (isTypeSelectionMode) {
-			void logEvent('Alert: New alert data source selection page visited', {});
+			logEvent('Alert: New alert data source selection page visited', {});
 		}
 	}, [isTypeSelectionMode]);
 
@@ -189,7 +187,6 @@ function CreateRules(): JSX.Element {
 	return (
 		<Tabs
 			destroyInactiveTabPane
-			animated={!prefersReducedMotion}
 			items={items}
 			activeKey={AlertListTabs.ALERT_RULES}
 			onChange={handleTabChange}

frontend/src/container/CreateAlertV2/Footer/styles.scss

@@ -29,3 +29,7 @@
 		color: var(--l2-foreground);
 	}
 }
+
+body.ai-assistant-panel-open .create-alert-v2-footer {
+	right: var(--ai-assistant-panel-width, 380px);
+}

frontend/src/container/NewWidget/NewWidget.styles.scss

@@ -39,6 +39,7 @@
 	.right-header {
 		display: flex;
 		gap: 16px;
+		align-items: center;
 	}
 }
 

frontend/src/container/NewWidget/index.tsx

@@ -15,6 +15,7 @@ import { Flex } from 'antd';
 import { Typography } from '@signozhq/ui/typography';
 import logEvent from 'api/common/logEvent';
 import { PrecisionOption, PrecisionOptionsEnum } from 'components/Graph/types';
+import HeaderRightSection from 'components/HeaderRightSection/HeaderRightSection';
 import OverlayScrollbar from 'components/OverlayScrollbar/OverlayScrollbar';
 import { adjustQueryForV5 } from 'components/QueryBuilderV2/utils';
 import { QueryParams } from 'constants/query';
@@ -820,6 +821,11 @@ function NewWidget({
 					</Flex>
 				</div>
 				<div className="right-header">
+					<HeaderRightSection
+						enableAnnouncements={false}
+						enableShare
+						enableFeedback
+					/>
 					{showSwitchToViewModeButton && (
 						<Button
 							color="primary"

frontend/src/hooks/__tests__/useReducedMotion.test.ts

@@ -1,80 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import useReducedMotion from 'hooks/useReducedMotion';
-
-type ChangeListener = (e: Partial<MediaQueryListEvent>) => void;
-
-function mockMatchMedia(matches: boolean): {
-	setMatches: (next: boolean) => void;
-} {
-	const listeners: ChangeListener[] = [];
-	let currentMatches = matches;
-
-	Object.defineProperty(window, 'matchMedia', {
-		writable: true,
-		value: jest.fn(() => ({
-			get matches() {
-				return currentMatches;
-			},
-			addEventListener: jest.fn((_: string, fn: ChangeListener) => {
-				listeners.push(fn);
-			}),
-			removeEventListener: jest.fn(),
-		})),
-	});
-
-	return {
-		setMatches: (next: boolean): void => {
-			currentMatches = next;
-			listeners.forEach((fn) => fn({ matches: next } as MediaQueryListEvent));
-		},
-	};
-}
-
-describe('useReducedMotion', () => {
-	it('returns false when prefers-reduced-motion is not set', () => {
-		mockMatchMedia(false);
-		const { result } = renderHook(() => useReducedMotion());
-		expect(result.current).toBe(false);
-	});
-
-	it('returns true when prefers-reduced-motion: reduce is active', () => {
-		mockMatchMedia(true);
-		const { result } = renderHook(() => useReducedMotion());
-		expect(result.current).toBe(true);
-	});
-
-	it('updates when system preference changes at runtime', () => {
-		const { setMatches } = mockMatchMedia(false);
-		const { result } = renderHook(() => useReducedMotion());
-		expect(result.current).toBe(false);
-
-		act(() => {
-			setMatches(true);
-		});
-		expect(result.current).toBe(true);
-
-		act(() => {
-			setMatches(false);
-		});
-		expect(result.current).toBe(false);
-	});
-
-	it('removes event listener on unmount', () => {
-		const removeEventListener = jest.fn();
-		Object.defineProperty(window, 'matchMedia', {
-			writable: true,
-			value: jest.fn(() => ({
-				matches: false,
-				addEventListener: jest.fn(),
-				removeEventListener,
-			})),
-		});
-
-		const { unmount } = renderHook(() => useReducedMotion());
-		unmount();
-		expect(removeEventListener).toHaveBeenCalledWith(
-			'change',
-			expect.any(Function),
-		);
-	});
-});

frontend/src/hooks/useReducedMotion.ts

@@ -1,20 +0,0 @@
-import { useEffect, useState } from 'react';
-
-function useReducedMotion(): boolean {
-	const [prefersReducedMotion, setPrefersReducedMotion] = useState<boolean>(
-		() => window.matchMedia('(prefers-reduced-motion: reduce)').matches,
-	);
-
-	useEffect(() => {
-		const mediaQuery = window.matchMedia('(prefers-reduced-motion: reduce)');
-		const onChange = (e: MediaQueryListEvent): void => {
-			setPrefersReducedMotion(e.matches);
-		};
-		mediaQuery.addEventListener('change', onChange);
-		return (): void => mediaQuery.removeEventListener('change', onChange);
-	}, []);
-
-	return prefersReducedMotion;
-}
-
-export default useReducedMotion;

frontend/src/pages/AlertList/index.tsx

@@ -8,7 +8,6 @@ import AllAlertRules from 'container/ListAlertRules';
 import { PlannedDowntime } from 'container/PlannedDowntime/PlannedDowntime';
 import RoutingPolicies from 'container/RoutingPolicies';
 import TriggeredAlerts from 'container/TriggeredAlerts';
-import useReducedMotion from 'hooks/useReducedMotion';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 import { GalleryVerticalEnd, Pyramid } from '@signozhq/icons';
@@ -22,7 +21,6 @@ function AllAlertList(): JSX.Element {
 	const urlQuery = useUrlQuery();
 	const location = useLocation();
 	const { safeNavigate } = useSafeNavigate();
-	const prefersReducedMotion = useReducedMotion();
 
 	const tab = urlQuery.get('tab');
 	const subTab = urlQuery.get('subTab');
@@ -103,7 +101,6 @@ function AllAlertList(): JSX.Element {
 	return (
 		<Tabs
 			destroyInactiveTabPane
-			animated={!prefersReducedMotion}
 			items={items}
 			activeKey={tab || AlertListTabs.ALERT_RULES}
 			onChange={(tab): void => {

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboard.module.scss

@@ -1,106 +0,0 @@
-// settings card wrapper — mirrors the V1 public dashboard treatment
-.publicDashboardCard {
-	display: flex;
-	flex-direction: column;
-	gap: 8px;
-	padding: 16px;
-	border-radius: 3px;
-	border: 1px solid var(--l2-border);
-}
-
-.statusTitle {
-	margin-bottom: 16px;
-	color: var(--l1-foreground);
-	font-family: Inter;
-	font-size: 14px;
-	font-weight: 500;
-	line-height: 20px;
-}
-
-.checkbox {
-	margin-bottom: 8px;
-}
-
-.timeRangeSelectGroup {
-	display: flex;
-	flex-direction: column;
-	gap: 4px;
-	margin-bottom: 8px;
-}
-
-.timeRangeSelectLabel {
-	color: var(--l2-foreground);
-	font-family: Inter;
-	font-size: 12px;
-	font-weight: 500;
-	line-height: 18px;
-}
-
-.timeRangeSelect {
-	width: 200px;
-}
-
-.urlGroup {
-	display: flex;
-	flex-direction: column;
-	gap: 4px;
-}
-
-.urlLabel {
-	color: var(--l2-foreground);
-	font-family: Inter;
-	font-size: 12px;
-	font-weight: 500;
-	line-height: 18px;
-}
-
-.urlContainer {
-	display: flex;
-	align-items: center;
-	gap: 8px;
-	padding: 0 4px;
-	border-radius: 4px;
-	border: 1px solid var(--l1-border);
-	background: var(--l3-background);
-}
-
-.urlText {
-	flex: 1;
-	overflow: hidden;
-	text-overflow: ellipsis;
-	white-space: nowrap;
-	color: var(--l2-foreground);
-	font-family: Inter;
-	font-size: 13px;
-	line-height: 32px;
-}
-
-.callout {
-	display: flex;
-	align-items: center;
-	gap: 8px;
-	margin-top: 12px;
-	padding: 12px 8px;
-	border-radius: 3px;
-	background: color-mix(in srgb, var(--primary-background) 10%, transparent);
-}
-
-.calloutIcon {
-	flex-shrink: 0;
-	color: var(--text-robin-300);
-}
-
-.calloutText {
-	color: var(--text-robin-300);
-	font-family: Inter;
-	font-size: 11px;
-	font-weight: 400;
-	line-height: 16px;
-}
-
-.actions {
-	display: flex;
-	justify-content: flex-end;
-	gap: 8px;
-	margin-top: 32px;
-}

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardActions.tsx

@@ -1,71 +0,0 @@
-import { Globe, Trash } from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
-
-import styles from './PublicDashboard.module.scss';
-
-interface PublicDashboardActionsProps {
-	isPublic: boolean;
-	disabled: boolean;
-	isPublishing: boolean;
-	isUpdating: boolean;
-	isUnpublishing: boolean;
-	onPublish: () => void;
-	onUpdate: () => void;
-	onUnpublish: () => void;
-}
-
-function PublicDashboardActions({
-	isPublic,
-	disabled,
-	isPublishing,
-	isUpdating,
-	isUnpublishing,
-	onPublish,
-	onUpdate,
-	onUnpublish,
-}: PublicDashboardActionsProps): JSX.Element {
-	return (
-		<div className={styles.actions}>
-			{isPublic ? (
-				<>
-					<Button
-						variant="outlined"
-						color="destructive"
-						disabled={disabled}
-						loading={isUnpublishing}
-						prefix={<Trash size={14} />}
-						testId="public-dashboard-unpublish"
-						onClick={onUnpublish}
-					>
-						Unpublish dashboard
-					</Button>
-					<Button
-						variant="solid"
-						color="primary"
-						disabled={disabled}
-						loading={isUpdating}
-						prefix={<Globe size={14} />}
-						testId="public-dashboard-update"
-						onClick={onUpdate}
-					>
-						Update published dashboard
-					</Button>
-				</>
-			) : (
-				<Button
-					variant="solid"
-					color="primary"
-					disabled={disabled}
-					loading={isPublishing}
-					prefix={<Globe size={14} />}
-					testId="public-dashboard-publish"
-					onClick={onPublish}
-				>
-					Publish dashboard
-				</Button>
-			)}
-		</div>
-	);
-}
-
-export default PublicDashboardActions;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardCallout.tsx

@@ -1,17 +0,0 @@
-import { Info } from '@signozhq/icons';
-import { Typography } from '@signozhq/ui/typography';
-
-import styles from './PublicDashboard.module.scss';
-
-function PublicDashboardCallout(): JSX.Element {
-	return (
-		<div className={styles.callout}>
-			<Info size={12} className={styles.calloutIcon} />
-			<Typography.Text className={styles.calloutText}>
-				Dashboard variables won&apos;t work in public dashboards
-			</Typography.Text>
-		</div>
-	);
-}
-
-export default PublicDashboardCallout;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardSettingsForm.tsx

@@ -1,54 +0,0 @@
-import { Checkbox } from '@signozhq/ui/checkbox';
-import { SelectSimple } from '@signozhq/ui/select';
-import { Typography } from '@signozhq/ui/typography';
-
-import { TIME_RANGE_PRESETS_OPTIONS } from './constants';
-import styles from './PublicDashboard.module.scss';
-
-interface PublicDashboardSettingsFormProps {
-	timeRangeEnabled: boolean;
-	defaultTimeRange: string;
-	disabled: boolean;
-	onTimeRangeEnabledChange: (value: boolean) => void;
-	onDefaultTimeRangeChange: (value: string) => void;
-}
-
-function PublicDashboardSettingsForm({
-	timeRangeEnabled,
-	defaultTimeRange,
-	disabled,
-	onTimeRangeEnabledChange,
-	onDefaultTimeRangeChange,
-}: PublicDashboardSettingsFormProps): JSX.Element {
-	return (
-		<>
-			<Checkbox
-				id="public-dashboard-enable-time-range"
-				className={styles.checkbox}
-				testId="public-dashboard-time-range-toggle"
-				value={timeRangeEnabled}
-				disabled={disabled}
-				onChange={(checked): void => onTimeRangeEnabledChange(checked === true)}
-			>
-				Enable time range
-			</Checkbox>
-
-			<div className={styles.timeRangeSelectGroup}>
-				<Typography.Text className={styles.timeRangeSelectLabel}>
-					Default time range
-				</Typography.Text>
-				<SelectSimple
-					className={styles.timeRangeSelect}
-					testId="public-dashboard-default-time-range"
-					placeholder="Select default time range"
-					items={TIME_RANGE_PRESETS_OPTIONS}
-					value={defaultTimeRange}
-					disabled={disabled}
-					onChange={(value): void => onDefaultTimeRangeChange(value as string)}
-				/>
-			</div>
-		</>
-	);
-}
-
-export default PublicDashboardSettingsForm;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardStatus.tsx

@@ -1,21 +0,0 @@
-import { Typography } from '@signozhq/ui/typography';
-
-import styles from './PublicDashboard.module.scss';
-
-interface PublicDashboardStatusProps {
-	isPublic: boolean;
-}
-
-function PublicDashboardStatus({
-	isPublic,
-}: PublicDashboardStatusProps): JSX.Element {
-	return (
-		<Typography.Text className={styles.statusTitle}>
-			{isPublic
-				? 'This dashboard is publicly accessible. Anyone with the link can view it.'
-				: 'This dashboard is private. Publish it to make it accessible to anyone with the link.'}
-		</Typography.Text>
-	);
-}
-
-export default PublicDashboardStatus;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/PublicDashboardUrl.tsx

@@ -1,49 +0,0 @@
-import { Copy, ExternalLink } from '@signozhq/icons';
-import { Button } from '@signozhq/ui/button';
-import { Typography } from '@signozhq/ui/typography';
-
-import styles from './PublicDashboard.module.scss';
-
-interface PublicDashboardUrlProps {
-	url: string;
-	onCopy: () => void;
-	onOpen: () => void;
-}
-
-function PublicDashboardUrl({
-	url,
-	onCopy,
-	onOpen,
-}: PublicDashboardUrlProps): JSX.Element {
-	return (
-		<div className={styles.urlGroup}>
-			<Typography.Text className={styles.urlLabel}>
-				Public dashboard URL
-			</Typography.Text>
-
-			<div className={styles.urlContainer}>
-				<Typography.Text className={styles.urlText}>{url}</Typography.Text>
-				<Button
-					variant="ghost"
-					size="icon"
-					aria-label="Copy public dashboard URL"
-					testId="public-dashboard-copy-url"
-					onClick={onCopy}
-				>
-					<Copy size={14} />
-				</Button>
-				<Button
-					variant="ghost"
-					size="icon"
-					aria-label="Open public dashboard in new tab"
-					testId="public-dashboard-open-url"
-					onClick={onOpen}
-				>
-					<ExternalLink size={14} />
-				</Button>
-			</div>
-		</div>
-	);
-}
-
-export default PublicDashboardUrl;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/constants.ts

@@ -1,14 +0,0 @@
-export interface TimeRangePresetOption {
-	label: string;
-	value: string;
-}
-
-// Default time-range presets offered for the public dashboard viewer.
-export const TIME_RANGE_PRESETS_OPTIONS: TimeRangePresetOption[] = [
-	{ label: 'Last 5 minutes', value: '5m' },
-	{ label: 'Last 15 minutes', value: '15m' },
-	{ label: 'Last 30 minutes', value: '30m' },
-	{ label: 'Last 1 hour', value: '1h' },
-	{ label: 'Last 6 hours', value: '6h' },
-	{ label: 'Last 1 day', value: '24h' },
-];

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/index.tsx

@@ -1,71 +0,0 @@
-import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
-
-import PublicDashboardActions from './PublicDashboardActions';
-import PublicDashboardCallout from './PublicDashboardCallout';
-import PublicDashboardSettingsForm from './PublicDashboardSettingsForm';
-import PublicDashboardStatus from './PublicDashboardStatus';
-import PublicDashboardUrl from './PublicDashboardUrl';
-import { usePublicDashboard } from './usePublicDashboard';
-import styles from './PublicDashboard.module.scss';
-
-interface PublicDashboardSettingsProps {
-	dashboard: DashboardtypesGettableDashboardV2DTO;
-}
-
-function PublicDashboardSettings({
-	dashboard,
-}: PublicDashboardSettingsProps): JSX.Element {
-	const {
-		isPublic,
-		isAdmin,
-		isLoading,
-		isPublishing,
-		isUpdating,
-		isUnpublishing,
-		timeRangeEnabled,
-		defaultTimeRange,
-		publicUrl,
-		setTimeRangeEnabled,
-		setDefaultTimeRange,
-		onPublish,
-		onUpdate,
-		onUnpublish,
-		onCopyUrl,
-		onOpenUrl,
-	} = usePublicDashboard(dashboard.id);
-
-	const controlsDisabled = isLoading || !isAdmin;
-
-	return (
-		<div className={styles.publicDashboardCard}>
-			<PublicDashboardStatus isPublic={isPublic} />
-
-			<PublicDashboardSettingsForm
-				timeRangeEnabled={timeRangeEnabled}
-				defaultTimeRange={defaultTimeRange}
-				disabled={controlsDisabled}
-				onTimeRangeEnabledChange={setTimeRangeEnabled}
-				onDefaultTimeRangeChange={setDefaultTimeRange}
-			/>
-
-			{isPublic && (
-				<PublicDashboardUrl url={publicUrl} onCopy={onCopyUrl} onOpen={onOpenUrl} />
-			)}
-
-			<PublicDashboardCallout />
-
-			<PublicDashboardActions
-				isPublic={isPublic}
-				disabled={controlsDisabled}
-				isPublishing={isPublishing}
-				isUpdating={isUpdating}
-				isUnpublishing={isUnpublishing}
-				onPublish={onPublish}
-				onUpdate={onUpdate}
-				onUnpublish={onUnpublish}
-			/>
-		</div>
-	);
-}
-
-export default PublicDashboardSettings;

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/PublicDashboard/usePublicDashboard.ts

@@ -1,197 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { useQueryClient } from 'react-query';
-import { useCopyToClipboard } from 'react-use';
-import { toast } from '@signozhq/ui/sonner';
-import {
-	invalidateGetPublicDashboard,
-	useCreatePublicDashboard,
-	useDeletePublicDashboard,
-	useGetPublicDashboard,
-	useUpdatePublicDashboard,
-} from 'api/generated/services/dashboard';
-import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constants';
-import { useAppContext } from 'providers/App/App';
-import { useErrorModal } from 'providers/ErrorModalProvider';
-import APIError from 'types/api/error';
-import { USER_ROLES } from 'types/roles';
-import { getAbsoluteUrl } from 'utils/basePath';
-import { openInNewTab } from 'utils/navigation';
-
-export interface UsePublicDashboardReturn {
-	isPublic: boolean;
-	isAdmin: boolean;
-	isLoading: boolean;
-	isPublishing: boolean;
-	isUpdating: boolean;
-	isUnpublishing: boolean;
-	timeRangeEnabled: boolean;
-	defaultTimeRange: string;
-	publicUrl: string;
-	setTimeRangeEnabled: (value: boolean) => void;
-	setDefaultTimeRange: (value: string) => void;
-	onPublish: () => void;
-	onUpdate: () => void;
-	onUnpublish: () => void;
-	onCopyUrl: () => void;
-	onOpenUrl: () => void;
-}
-
-/**
- * Encapsulates the public-dashboard query, the create/update/delete mutations and the
- * local form state for the V2 publish settings section. Targets the same
- * `/dashboards/{id}/public` endpoint as V1 via the generated client.
- */
-export function usePublicDashboard(
-	dashboardId: string,
-): UsePublicDashboardReturn {
-	const queryClient = useQueryClient();
-	const { showErrorModal } = useErrorModal();
-	const { user } = useAppContext();
-	const isAdmin = user?.role === USER_ROLES.ADMIN;
-	const [, copyToClipboard] = useCopyToClipboard();
-
-	const [timeRangeEnabled, setTimeRangeEnabled] = useState<boolean>(true);
-	const [defaultTimeRange, setDefaultTimeRange] =
-		useState<string>(DEFAULT_TIME_RANGE);
-
-	const {
-		data,
-		isLoading: isLoadingMeta,
-		isFetching,
-		error,
-		refetch,
-	} = useGetPublicDashboard(
-		{ id: dashboardId },
-		{ query: { enabled: !!dashboardId, retry: false } },
-	);
-
-	// react-query retains the last successful `data` even after a refetch errors, so
-	// after unpublishing (the refetch 404s) `data` still holds the old publicPath.
-	// Gate on `!error` so the UI flips back to the private state.
-	const publicMeta = error ? undefined : data?.data;
-	const isPublic = !!publicMeta?.publicPath;
-
-	// Seed form state from the server config when published.
-	useEffect(() => {
-		if (publicMeta) {
-			setTimeRangeEnabled(publicMeta.timeRangeEnabled ?? false);
-			setDefaultTimeRange(publicMeta.defaultTimeRange || DEFAULT_TIME_RANGE);
-		}
-	}, [publicMeta]);
-
-	// A 404 (dashboard not published) surfaces as an error — reset to defaults.
-	useEffect(() => {
-		if (error) {
-			setTimeRangeEnabled(true);
-			setDefaultTimeRange(DEFAULT_TIME_RANGE);
-		}
-	}, [error]);
-
-	const publicUrl = useMemo(
-		() => getAbsoluteUrl(publicMeta?.publicPath ?? ''),
-		[publicMeta?.publicPath],
-	);
-
-	const handleError = useCallback(
-		(err: unknown): void => {
-			showErrorModal(err as APIError);
-		},
-		[showErrorModal],
-	);
-
-	const handleSuccess = useCallback(
-		(message: string): void => {
-			toast.success(message);
-			void invalidateGetPublicDashboard(queryClient, { id: dashboardId });
-			void refetch();
-		},
-		[queryClient, dashboardId, refetch],
-	);
-
-	const { mutate: createPublicDashboard, isLoading: isPublishing } =
-		useCreatePublicDashboard({
-			mutation: {
-				onSuccess: () => handleSuccess('Dashboard published successfully'),
-				onError: handleError,
-			},
-		});
-
-	const { mutate: updatePublicDashboard, isLoading: isUpdating } =
-		useUpdatePublicDashboard({
-			mutation: {
-				onSuccess: () => handleSuccess('Public dashboard updated successfully'),
-				onError: handleError,
-			},
-		});
-
-	const { mutate: deletePublicDashboard, isLoading: isUnpublishing } =
-		useDeletePublicDashboard({
-			mutation: {
-				onSuccess: () => handleSuccess('Dashboard unpublished successfully'),
-				onError: handleError,
-			},
-		});
-
-	const onPublish = useCallback((): void => {
-		if (!dashboardId) {
-			return;
-		}
-		createPublicDashboard({
-			pathParams: { id: dashboardId },
-			data: { timeRangeEnabled, defaultTimeRange },
-		});
-	}, [createPublicDashboard, dashboardId, timeRangeEnabled, defaultTimeRange]);
-
-	const onUpdate = useCallback((): void => {
-		if (!dashboardId) {
-			return;
-		}
-		updatePublicDashboard({
-			pathParams: { id: dashboardId },
-			data: { timeRangeEnabled, defaultTimeRange },
-		});
-	}, [updatePublicDashboard, dashboardId, timeRangeEnabled, defaultTimeRange]);
-
-	const onUnpublish = useCallback((): void => {
-		if (!dashboardId) {
-			return;
-		}
-		deletePublicDashboard({ pathParams: { id: dashboardId } });
-	}, [deletePublicDashboard, dashboardId]);
-
-	const onCopyUrl = useCallback((): void => {
-		if (!publicUrl) {
-			return;
-		}
-		copyToClipboard(publicUrl);
-		toast.success('Copied public dashboard URL successfully');
-	}, [copyToClipboard, publicUrl]);
-
-	const onOpenUrl = useCallback((): void => {
-		if (publicUrl) {
-			openInNewTab(publicUrl);
-		}
-	}, [publicUrl]);
-
-	const isLoading =
-		isLoadingMeta || isFetching || isPublishing || isUpdating || isUnpublishing;
-
-	return {
-		isPublic,
-		isAdmin,
-		isLoading,
-		isPublishing,
-		isUpdating,
-		isUnpublishing,
-		timeRangeEnabled,
-		defaultTimeRange,
-		publicUrl,
-		setTimeRangeEnabled,
-		setDefaultTimeRange,
-		onPublish,
-		onUpdate,
-		onUnpublish,
-		onCopyUrl,
-		onOpenUrl,
-	};
-}

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

@@ -11,7 +11,7 @@ import {
 import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
 
 import Overview from './Overview';
-import PublicDashboardSettings from './PublicDashboard';
+import { SettingsTabPlaceholder } from './utils';
 import VariablesSettings from './Variables';
 import { useAppContext } from 'providers/App/App';
 import { useGetTenantLicense } from 'hooks/useGetTenantLicense';
@@ -52,14 +52,15 @@ function DashboardSettings({ dashboard }: DashboardSettingsProps): JSX.Element {
 				key: TabKeys.VARIABLES,
 				label: TabKeys.VARIABLES,
 				children: <VariablesSettings dashboard={dashboard} />,
-				prefixIcon: <Braces size={14} />,
 			},
 			...(enablePublicDashboard
 				? [
 						{
 							key: TabKeys.PUBLISH,
 							label: TabKeys.PUBLISH,
-							children: <PublicDashboardSettings dashboard={dashboard} />,
+							children: (
+								<SettingsTabPlaceholder message="V2 public dashboard publishing coming next." />
+							),
 							disabled: user?.role !== USER_ROLES.ADMIN,
 						},
 					]

frontend/src/pages/DashboardPageV2/DashboardContainer/DashboardSettings/utils.tsx

@@ -0,0 +1,23 @@
+import { Empty } from 'antd';
+import { Typography } from '@signozhq/ui/typography';
+
+import styles from './DashboardSettings.module.scss';
+
+/**
+ * TEMPORARY: stand-in for the not-yet-built Variables / Publish settings tabs.
+ * Will be cleaned up later once those tabs ship their real content.
+ */
+export function SettingsTabPlaceholder({
+	message,
+}: {
+	message: string;
+}): JSX.Element {
+	return (
+		<div className={styles.placeholder}>
+			<Empty
+				image={Empty.PRESENTED_IMAGE_SIMPLE}
+				description={<Typography.Text>{message}</Typography.Text>}
+			/>
+		</div>
+	);
+}

frontend/src/pages/MetricsApplication/MetricsApplication.tsx

@@ -5,7 +5,6 @@ import DBCall from 'container/MetricsApplication/Tabs/DBCall';
 import External from 'container/MetricsApplication/Tabs/External';
 import Overview from 'container/MetricsApplication/Tabs/Overview';
 import ResourceAttributesFilter from 'container/ResourceAttributesFilter';
-import useReducedMotion from 'hooks/useReducedMotion';
 import { useSafeNavigate } from 'hooks/useSafeNavigate';
 import useUrlQuery from 'hooks/useUrlQuery';
 
@@ -21,7 +20,6 @@ function MetricsApplication(): JSX.Element {
 	}>();
 
 	const activeKey = useMetricsApplicationTabKey();
-	const prefersReducedMotion = useReducedMotion();
 
 	const urlQuery = useUrlQuery();
 	const { safeNavigate } = useSafeNavigate();
@@ -58,7 +56,6 @@ function MetricsApplication(): JSX.Element {
 				activeKey={activeKey}
 				className="service-route-tab"
 				destroyInactiveTabPane
-				animated={!prefersReducedMotion}
 				onChange={onTabChange}
 			/>
 		</div>

pkg/apiserver/signozapiserver/provider.go

@@ -31,7 +31,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/ruler"
-	"github.com/SigNoz/signoz/pkg/statsreporter"
 	"github.com/SigNoz/signoz/pkg/types"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/zeus"
@@ -71,7 +70,6 @@ type provider struct {
 	traceDetailHandler      tracedetail.Handler
 	rulerHandler            ruler.Handler
 	llmPricingRuleHandler   llmpricingrule.Handler
-	statsHandler            statsreporter.Handler
 }
 
 func NewFactory(
@@ -104,7 +102,6 @@ func NewFactory(
 	llmPricingRuleHandler llmpricingrule.Handler,
 	traceDetailHandler tracedetail.Handler,
 	rulerHandler ruler.Handler,
-	statsHandler statsreporter.Handler,
 ) factory.ProviderFactory[apiserver.APIServer, apiserver.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("signoz"), func(ctx context.Context, providerSettings factory.ProviderSettings, config apiserver.Config) (apiserver.APIServer, error) {
 		return newProvider(
@@ -140,7 +137,6 @@ func NewFactory(
 			llmPricingRuleHandler,
 			traceDetailHandler,
 			rulerHandler,
-			statsHandler,
 		)
 	})
 }
@@ -178,7 +174,6 @@ func newProvider(
 	llmPricingRuleHandler llmpricingrule.Handler,
 	traceDetailHandler tracedetail.Handler,
 	rulerHandler ruler.Handler,
-	statsHandler statsreporter.Handler,
 ) (apiserver.APIServer, error) {
 	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/apiserver/signozapiserver")
 	router := mux.NewRouter().UseEncodedPath()
@@ -215,7 +210,6 @@ func newProvider(
 		traceDetailHandler:      traceDetailHandler,
 		rulerHandler:            rulerHandler,
 		llmPricingRuleHandler:   llmPricingRuleHandler,
-		statsHandler:            statsHandler,
 	}
 
 	provider.authzMiddleware = middleware.NewAuthZ(settings.Logger(), orgGetter, authzService)
@@ -340,10 +334,6 @@ func (provider *provider) AddToRouter(router *mux.Router) error {
 		return err
 	}
 
-	if err := provider.addStatsReporterRoutes(router); err != nil {
-		return err
-	}
-
 	return nil
 }
 

pkg/apiserver/signozapiserver/statsreporter.go

@@ -1,33 +0,0 @@
-package signozapiserver
-
-import (
-	"net/http"
-
-	"github.com/SigNoz/signoz/pkg/http/handler"
-	"github.com/SigNoz/signoz/pkg/types"
-	"github.com/gorilla/mux"
-)
-
-func (provider *provider) addStatsReporterRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v1/stats", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.statsHandler.Get),
-		handler.OpenAPIDef{
-			ID:                  "GetStats",
-			Tags:                []string{"stats"},
-			Summary:             "Get stats",
-			Description:         "This endpoint returns the collected stats for the organization",
-			Request:             nil,
-			RequestContentType:  "",
-			Response:            map[string]any{},
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{},
-			Deprecated:          false,
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodGet).GetError(); err != nil {
-		return err
-	}
-
-	return nil
-}

pkg/errors/errors.go

@@ -21,25 +21,18 @@ type base struct {
 	e error
 	// u denotes the url for the documentation (if present) for the error.
 	u string
-	// a denotes any additional error details (if present). Each detail carries an
-	// optional message and any user-facing suggestions closely related to it.
-	a []additional
+	// a denotes any additional error messages (if present).
+	a []string
 	// s contains the stacktrace captured at error creation time.
 	s fmt.Stringer
 	// r is the retry strategy for the error, if applicable.
 	r *retry
-	// suggestions is a list of user-facing suggestions related to the error as a
-	// whole (not tied to a specific detail in a), if present. For example,
-	// "narrow the time range window". For a suggestion tied to a specific detail,
-	// use the suggestions field on additional instead.
-	suggestions []string
-}
-
-// additional is a single supplementary error detail: a message plus any
-// user-facing suggestions (e.g. "did you mean: `x`") closely related to it.
-type additional struct {
-	message     string
+	// suggestions is a list of user-facing suggestions related to the error, if present.
+	// For example, narrow the time range window or typo suggestion
 	suggestions []string
+	// invalidReferences is a list of references that were invalid and contributed to the error, if present.
+	// For example, a typo from user avg(sum), we return invalidRefences: ['sum']
+	invalidReferences []string
 }
 
 // Stacktrace returns the stacktrace captured at error creation time, formatted as a string.
@@ -54,15 +47,16 @@ func (b *base) Stacktrace() string {
 // and returns a new base error.
 func (b *base) WithStacktrace(s string) *base {
 	return &base{
-		t:           b.t,
-		c:           b.c,
-		m:           b.m,
-		e:           b.e,
-		u:           b.u,
-		a:           b.a,
-		s:           rawStacktrace(s),
-		r:           b.r,
-		suggestions: b.suggestions,
+		t:                 b.t,
+		c:                 b.c,
+		m:                 b.m,
+		e:                 b.e,
+		u:                 b.u,
+		a:                 b.a,
+		s:                 rawStacktrace(s),
+		r:                 b.r,
+		suggestions:       b.suggestions,
+		invalidReferences: b.invalidReferences,
 	}
 }
 
@@ -83,7 +77,7 @@ func New(t typ, code Code, message string) *base {
 		m: message,
 		e: nil,
 		u: "",
-		a: []additional{},
+		a: []string{},
 		s: newStackTrace(),
 	}
 }
@@ -102,144 +96,127 @@ func Newf(t typ, code Code, format string, args ...any) *base {
 // Wrapf returns a new error by formatting the error message with the supplied format specifier
 // and wrapping another error with base.
 func Wrapf(cause error, t typ, code Code, format string, args ...any) *base {
-	b := &base{
+	return &base{
 		t: t,
 		c: code,
 		m: fmt.Sprintf(format, args...),
 		e: cause,
 		s: newStackTrace(),
 	}
-
-	// Carry the user-facing hints forward from the wrapped cause. Otherwise
-	// wrapping a structured error (e.g. one returned from an UnmarshalJSON) would
-	// silently drop its suggestions / invalid references from the response.
-	// Propagation is transitive: each Wrapf copies from its immediate cause, so
-	// the hints survive arbitrarily deep wrapping as long as it goes through Wrapf.
-	if inner, ok := cause.(*base); ok {
-		b.r = inner.r
-		b.a = inner.a
-		b.suggestions = inner.suggestions
-	}
-
-	return b
 }
 
 // Wrap returns a new error by wrapping another error with base.
 func Wrap(cause error, t typ, code Code, message string) *base {
-	b := &base{
+	return &base{
 		t: t,
 		c: code,
 		m: message,
 		e: cause,
 		s: newStackTrace(),
 	}
-
-	// Carry the user-facing hints forward from the wrapped cause. Otherwise
-	// wrapping a structured error (e.g. one returned from an UnmarshalJSON) would
-	// silently drop its suggestions / invalid references from the response.
-	// Propagation is transitive: each Wrapf copies from its immediate cause, so
-	// the hints survive arbitrarily deep wrapping as long as it goes through Wrapf.
-	if inner, ok := cause.(*base); ok {
-		b.r = inner.r
-		b.a = inner.a
-		b.suggestions = inner.suggestions
-	}
-
-	return b
 }
 
 // WithAdditionalf adds an additional error message to the existing error.
 func WithAdditionalf(cause error, format string, args ...any) *base {
-	if b, ok := cause.(*base); ok {
-		return b.WithAdditional(fmt.Sprintf(format, args...))
+	t, c, m, e, u, a := Unwrapb(cause)
+	var s fmt.Stringer
+	if original, ok := cause.(*base); ok {
+		s = original.s
+	}
+	b := &base{
+		t:                 t,
+		c:                 c,
+		m:                 m,
+		e:                 e,
+		u:                 u,
+		a:                 a,
+		s:                 s,
+		r:                 retryOf(cause),
+		suggestions:       suggestionsOf(cause),
+		invalidReferences: invalidReferencesOf(cause),
 	}
 
-	t, c, m, e, u, a := Unwrapb(cause)
-	b := &base{t: t, c: c, m: m, e: e, u: u, a: a, s: newStackTrace(), r: retryOf(cause)}
-	return b.WithAdditional(fmt.Sprintf(format, args...))
-}
-
-// WithSuggestiveAdditionalf appends a detail whose message is built from the format
-// specifier and which carries the given user-facing suggestions closely related to
-// it, returning a new base error.
-func WithSuggestiveAdditionalf(cause error, suggestions []string, format string, args ...any) *base {
-	if b, ok := cause.(*base); ok {
-		return b.WithSuggestiveAdditional(fmt.Sprintf(format, args...), suggestions...)
-	}
-
-	t, c, m, e, u, a := Unwrapb(cause)
-	b := &base{t: t, c: c, m: m, e: e, u: u, a: a, s: newStackTrace(), r: retryOf(cause)}
-	return b.WithSuggestiveAdditional(fmt.Sprintf(format, args...), suggestions...)
+	return b.WithAdditional(append(a, fmt.Sprintf(format, args...))...)
 }
 
 // WithUrl adds a url to the base error and returns a new base error.
 func (b *base) WithUrl(u string) *base {
 	return &base{
-		t:           b.t,
-		c:           b.c,
-		m:           b.m,
-		e:           b.e,
-		u:           u,
-		a:           b.a,
-		s:           b.s,
-		r:           b.r,
-		suggestions: b.suggestions,
+		t:                 b.t,
+		c:                 b.c,
+		m:                 b.m,
+		e:                 b.e,
+		u:                 u,
+		a:                 b.a,
+		s:                 b.s,
+		r:                 b.r,
+		suggestions:       b.suggestions,
+		invalidReferences: b.invalidReferences,
 	}
 }
 
-// WithAdditional appends one or more message-only details and returns a new base error.
-func (b *base) WithAdditional(messages ...string) *base {
-	extra := make([]additional, len(messages))
-	for i, m := range messages {
-		extra[i] = additional{message: m}
+// WithAdditional adds additional messages to the base error and returns a new base error.
+func (b *base) WithAdditional(a ...string) *base {
+	return &base{
+		t:                 b.t,
+		c:                 b.c,
+		m:                 b.m,
+		e:                 b.e,
+		u:                 b.u,
+		a:                 a,
+		s:                 b.s,
+		r:                 b.r,
+		suggestions:       b.suggestions,
+		invalidReferences: b.invalidReferences,
 	}
-	return b.WithAdditionals(extra...)
-}
-
-// WithAdditionals appends the given details and returns a new base error. It is also
-// the way to re-attach details previously pulled out via Unwrapb.
-func (b *base) WithAdditionals(additionals ...additional) *base {
-	nb := *b
-	nb.a = append(append([]additional{}, b.a...), additionals...)
-	return &nb
 }
 
 // withRetry adds retry metadata to the base error and returns a new base error.
 func (b *base) withRetry(r retry) *base {
 	return &base{
-		t:           b.t,
-		c:           b.c,
-		m:           b.m,
-		e:           b.e,
-		u:           b.u,
-		a:           b.a,
-		s:           b.s,
-		r:           &r,
-		suggestions: b.suggestions,
+		t:                 b.t,
+		c:                 b.c,
+		m:                 b.m,
+		e:                 b.e,
+		u:                 b.u,
+		a:                 b.a,
+		s:                 b.s,
+		r:                 &r,
+		suggestions:       b.suggestions,
+		invalidReferences: b.invalidReferences,
 	}
 }
 
-// WithSuggestions replaces the error-wide suggestions and returns a new base error.
-// These relate to the error as a whole; for a suggestion tied to a specific detail,
-// use WithSuggestiveAdditional.
+// WithSuggestions replaces the list of suggestions on the base error.
 func (b *base) WithSuggestions(suggestions ...string) *base {
 	return &base{
-		t:           b.t,
-		c:           b.c,
-		m:           b.m,
-		e:           b.e,
-		u:           b.u,
-		a:           b.a,
-		s:           b.s,
-		r:           b.r,
-		suggestions: suggestions,
+		t:                 b.t,
+		c:                 b.c,
+		m:                 b.m,
+		e:                 b.e,
+		u:                 b.u,
+		a:                 b.a,
+		s:                 b.s,
+		r:                 b.r,
+		suggestions:       suggestions,
+		invalidReferences: b.invalidReferences,
 	}
 }
 
-// WithSuggestiveAdditional appends a detail carrying a message together with the
-// user-facing suggestions closely related to it, and returns a new base error.
-func (b *base) WithSuggestiveAdditional(message string, suggestions ...string) *base {
-	return b.WithAdditionals(additional{message: message, suggestions: suggestions})
+// WithInvalidReferences replaces the list of invalid references on the base error.
+func (b *base) WithInvalidReferences(invalidReferences ...string) *base {
+	return &base{
+		t:                 b.t,
+		c:                 b.c,
+		m:                 b.m,
+		e:                 b.e,
+		u:                 b.u,
+		a:                 b.a,
+		s:                 b.s,
+		r:                 b.r,
+		suggestions:       b.suggestions,
+		invalidReferences: invalidReferences,
+	}
 }
 
 // WithRetryAfter sets the retry delay on the base error and returns a new base error.
@@ -254,13 +231,13 @@ func (b *base) WithRetryAfter(delay time.Duration) *base {
 // and the error itself.
 //
 //nolint:staticcheck // ST1008: intentional return order matching struct field order (TCMEUA)
-func Unwrapb(cause error) (typ, Code, string, error, string, []additional) {
+func Unwrapb(cause error) (typ, Code, string, error, string, []string) {
 	base, ok := cause.(*base)
 	if ok {
 		return base.t, base.c, base.m, base.e, base.u, base.a
 	}
 
-	return TypeInternal, CodeUnknown, cause.Error(), cause, "", []additional{}
+	return TypeInternal, CodeUnknown, cause.Error(), cause, "", []string{}
 }
 
 // Ast checks if the provided error matches the specified custom error type.
@@ -394,3 +371,11 @@ func suggestionsOf(err error) []string {
 	}
 	return nil
 }
+
+func invalidReferencesOf(err error) []string {
+	base, ok := err.(*base)
+	if ok {
+		return base.invalidReferences
+	}
+	return nil
+}

pkg/errors/errors_test.go

@@ -48,7 +48,7 @@ func TestUnwrapb(t *testing.T) {
 	assert.Equal(t, "this is a base err", amessage)
 	assert.Equal(t, oerr, aerr)
 	assert.Equal(t, "https://docs", au)
-	assert.Equal(t, []additional{{message: "additional err"}}, aa)
+	assert.Equal(t, []string{"additional err"}, aa)
 
 	atyp, _, _, _, _, _ = Unwrapb(oerr)
 	assert.Equal(t, TypeInternal, atyp)
@@ -74,19 +74,6 @@ func TestWithSuggestions(t *testing.T) {
 	assert.Equal(t, []string{"first", "second"}, suggestionsOf(err))
 }
 
-func TestWithSuggestiveAdditional(t *testing.T) {
-	// WithSuggestiveAdditional attaches suggestions to a specific detail (in the
-	// errors array), distinct from the error-wide WithSuggestions.
-	err := NewInvalidInputf(MustNewCode("bad_field"), "unknown field %q", "filed").
-		WithSuggestiveAdditional("field `filed` not found", "did you mean: `field`")
-
-	j := AsJSON(err)
-	assert.Equal(t, []responseerroradditional{
-		{Message: "field `filed` not found", Suggestions: []string{"did you mean: `field`"}},
-	}, j.Errors)
-	assert.Nil(t, j.Suggestions, "detail-scoped suggestions must not leak into the error-wide list")
-}
-
 func TestWithRetryAfter(t *testing.T) {
 	err := New(TypeInternal, MustNewCode("test_code"), "test error").WithRetryAfter(5 * time.Microsecond)
 	r := retryOf(err)
@@ -94,11 +81,24 @@ func TestWithRetryAfter(t *testing.T) {
 	assert.Equal(t, 5, int(r.delay.Microseconds()))
 }
 
+func TestWithInvalidReferences(t *testing.T) {
+	// WithInvalidReferences populates the list.
+	err := New(TypeInvalidInput, MustNewCode("bad_ref"), "bad ref").
+		WithInvalidReferences("queries[0]", "queries[1]")
+	assert.Equal(t, []string{"queries[0]", "queries[1]"}, invalidReferencesOf(err))
+
+	// WithInvalidReferences replaces the entire list on each call.
+	err = err.WithInvalidReferences("queries[2]")
+	assert.Equal(t, []string{"queries[2]"}, invalidReferencesOf(err),
+		"WithInvalidReferences must replace the entire list")
+}
+
 func TestAsJSONBaseError(t *testing.T) {
 	err := New(TypeInvalidInput, MustNewCode("bad_input"), "field foo is bad").
 		WithUrl("https://docs/bad_input").
 		WithAdditional("hint1", "hint2").
-		WithSuggestions("try this")
+		WithSuggestions("try this").
+		WithInvalidReferences("queries[0]")
 
 	j := AsJSON(err)
 
@@ -113,20 +113,7 @@ func TestAsJSONBaseError(t *testing.T) {
 	assert.Nil(t, j.Retry, "bare New(...) should not populate a retry block")
 
 	assert.Equal(t, []string{"try this"}, j.Suggestions)
-}
-
-func TestAsJSONWrappedErrorPreservesHints(t *testing.T) {
-	// An inner base carries the user-facing hints (e.g. produced inside an
-	// UnmarshalJSON), then gets re-wrapped (e.g. WrapInvalidInputf). suggestionsOf
-	// must walk the cause chain so the hints still surface.
-	inner := NewInvalidInputf(MustNewCode("bad_kind"), "unknown panel kind %q", "boom").
-		WithSuggestions("valid references: a, b, c")
-
-	wrapped := WrapInvalidInputf(inner, MustNewCode("outer"), "%s", inner.Error())
-
-	j := AsJSON(wrapped)
-	assert.Equal(t, []string{"valid references: a, b, c"}, j.Suggestions,
-		"suggestions on an inner base must survive wrapping")
+	assert.Equal(t, []string{"queries[0]"}, j.InvalidReferences)
 }
 
 func TestAsJSONRetryBlock(t *testing.T) {
@@ -160,6 +147,7 @@ func TestAsJSONRetryBlock(t *testing.T) {
 func TestAsJSONOptionalFieldsOmittedWhenEmpty(t *testing.T) {
 	j := AsJSON(New(TypeInternal, MustNewCode("boom"), "boom"))
 	assert.Nil(t, j.Suggestions, "no suggestions set => Suggestions must be nil so json omitempty drops it")
+	assert.Nil(t, j.InvalidReferences, "no invalid references set => InvalidReferences must be nil so json omitempty drops it")
 }
 
 func TestWithStacktrace(t *testing.T) {

pkg/errors/http.go

@@ -7,13 +7,14 @@ import (
 )
 
 type JSON struct {
-	Type        string                    `json:"type,omitempty"`
-	Code        string                    `json:"code" required:"true"`
-	Message     string                    `json:"message" required:"true"`
-	Url         string                    `json:"url,omitempty"`
-	Errors      []responseerroradditional `json:"errors,omitempty"`
-	Retry       *responseretryjson        `json:"retry,omitempty"`
-	Suggestions []string                  `json:"suggestions,omitempty"`
+	Type              string                    `json:"type,omitempty"`
+	Code              string                    `json:"code" required:"true"`
+	Message           string                    `json:"message" required:"true"`
+	Url               string                    `json:"url,omitempty"`
+	Errors            []responseerroradditional `json:"errors,omitempty"`
+	Retry             *responseretryjson        `json:"retry,omitempty"`
+	Suggestions       []string                  `json:"suggestions,omitempty"`
+	InvalidReferences []string                  `json:"invalidReferences,omitempty"`
 }
 
 type responseretryjson struct {
@@ -21,8 +22,7 @@ type responseretryjson struct {
 }
 
 type responseerroradditional struct {
-	Message     string   `json:"message,omitempty"`
-	Suggestions []string `json:"suggestions,omitempty"`
+	Message string `json:"message"`
 }
 
 func AsJSON(cause error) *JSON {
@@ -31,7 +31,7 @@ func AsJSON(cause error) *JSON {
 
 	rea := make([]responseerroradditional, len(a))
 	for k, v := range a {
-		rea[k] = responseerroradditional{Message: v.message, Suggestions: v.suggestions}
+		rea[k] = responseerroradditional{v}
 	}
 
 	var retry *responseretryjson
@@ -40,13 +40,14 @@ func AsJSON(cause error) *JSON {
 	}
 
 	return &JSON{
-		Type:        t.String(),
-		Code:        c.String(),
-		Message:     m,
-		Url:         u,
-		Errors:      rea,
-		Retry:       retry,
-		Suggestions: suggestionsOf(cause),
+		Type:              t.String(),
+		Code:              c.String(),
+		Message:           m,
+		Url:               u,
+		Errors:            rea,
+		Retry:             retry,
+		Suggestions:       suggestionsOf(cause),
+		InvalidReferences: invalidReferencesOf(cause),
 	}
 }
 
@@ -56,7 +57,7 @@ func AsURLValues(cause error) url.Values {
 
 	rea := make([]responseerroradditional, len(a))
 	for k, v := range a {
-		rea[k] = responseerroradditional{Message: v.message, Suggestions: v.suggestions}
+		rea[k] = responseerroradditional{v}
 	}
 
 	errors, err := json.Marshal(rea)

pkg/errors/suggestions.go

@@ -1,165 +0,0 @@
-package errors
-
-import (
-	"fmt"
-	"strings"
-)
-
-const (
-	typoSuggestionThreshold = 0.75
-	// maxValidReferences caps how many valid references are listed so
-	// high-cardinality sets (e.g. telemetry field keys) don't dump the entire
-	// set into the error.
-	maxValidReferences = 20
-)
-
-// SuggestionsOnLevenshteinDistance returns a "did you mean" correction (only
-// when a close match at least typoSuggestionThreshold similar exists) followed
-// by the valid-references list.
-func SuggestionsOnLevenshteinDistance(invalidInput string, validInputs []string) []string {
-	suggestions := make([]string, 0, 2)
-
-	if match, ok := ClosestLevenshteinMatch(invalidInput, validInputs); ok {
-		suggestions = append(suggestions, didYouMean(match))
-	}
-
-	if refs := ValidReferences(validInputs...); refs != "" {
-		suggestions = append(suggestions, refs)
-	}
-
-	return suggestions
-}
-
-// ClosestLevenshteinMatch returns the candidate most similar to input that is at least
-// typoSuggestionThreshold similar, or false when nothing is close enough.
-func ClosestLevenshteinMatch(input string, candidates []string) (string, bool) {
-	var bestMatch string
-	bestSimilarity := 0.0
-
-	for _, candidate := range candidates {
-		sim := similarity(input, candidate)
-
-		if sim > bestSimilarity && sim >= typoSuggestionThreshold {
-			bestSimilarity = sim
-			bestMatch = candidate
-		}
-	}
-
-	if bestSimilarity >= typoSuggestionThreshold {
-		return bestMatch, true
-	}
-
-	return "", false
-}
-
-// SuggestionsFromFunc formats the string produce returns as a one-element
-// "did you mean: `x`" slice, or nil when it returns the empty string (so callers
-// with their own matching strategy compose into a suggestions list cleanly).
-func SuggestionsFromFunc(produce func() string) []string {
-	s := produce()
-	if s == "" {
-		return nil
-	}
-
-	return []string{didYouMean(s)}
-}
-
-// ValidReferences formats values as "valid references: `a`, `b`", capped at
-// maxValidReferences with a "(+N more)" suffix. Each value is rendered as its
-// own string, an Enum() element's StringValue(), or fmt.Sprint as a fallback.
-// It returns "" when there are no values, so callers don't surface a bare
-// "valid references: " with nothing after it.
-func ValidReferences[T any](values ...T) string {
-	if len(values) == 0 {
-		return ""
-	}
-
-	refs := make([]string, 0, len(values))
-	for _, v := range values {
-		switch t := any(v).(type) {
-		case string:
-			refs = append(refs, t)
-		case interface{ StringValue() string }:
-			refs = append(refs, t.StringValue())
-		default:
-			refs = append(refs, fmt.Sprint(t))
-		}
-	}
-
-	truncated := 0
-	if len(refs) > maxValidReferences {
-		truncated = len(refs) - maxValidReferences
-		refs = refs[:maxValidReferences]
-	}
-
-	quoted := make([]string, len(refs))
-	for i, r := range refs {
-		quoted[i] = "`" + r + "`"
-	}
-
-	out := "valid references: " + strings.Join(quoted, ", ")
-	if truncated > 0 {
-		out += fmt.Sprintf(" (+%d more)", truncated)
-	}
-
-	return out
-}
-
-func levenshteinDistance(s1, s2 string) int {
-	s1 = strings.ToLower(s1)
-	s2 = strings.ToLower(s2)
-
-	if len(s1) == 0 {
-		return len(s2)
-	}
-
-	if len(s2) == 0 {
-		return len(s1)
-	}
-
-	v0 := make([]int, len(s2)+1)
-	v1 := make([]int, len(s2)+1)
-
-	for i := 0; i <= len(s2); i++ {
-		v0[i] = i
-	}
-
-	for i := range len(s1) {
-		v1[0] = i + 1
-
-		for j := range len(s2) {
-			deletionCost := v0[j+1] + 1
-			insertionCost := v1[j] + 1
-
-			var substitutionCost int
-			if s1[i] == s2[j] {
-				substitutionCost = v0[j]
-			} else {
-				substitutionCost = v0[j] + 1
-			}
-
-			v1[j+1] = min(deletionCost, insertionCost, substitutionCost)
-		}
-
-		for j := 0; j <= len(s2); j++ {
-			v0[j] = v1[j]
-		}
-	}
-
-	return v1[len(s2)]
-}
-
-func similarity(s1, s2 string) float64 {
-	maxLen := max(len(s1), len(s2))
-	if maxLen == 0 {
-		return 1.0
-	}
-
-	distance := levenshteinDistance(s1, s2)
-	return 1.0 - float64(distance)/float64(maxLen)
-}
-
-// didYouMean formats a correction as "did you mean: `x`".
-func didYouMean(match string) string {
-	return "did you mean: `" + match + "`"
-}

pkg/errors/suggestions_test.go

@@ -1,31 +0,0 @@
-package errors
-
-import (
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestValidReferences(t *testing.T) {
-	// An empty set returns "" so callers don't surface a bare "valid references: ".
-	assert.Equal(t, "", ValidReferences[string]())
-
-	assert.Equal(t, "valid references: `a`, `b`", ValidReferences("a", "b"))
-}
-
-func TestSuggestionsOnLevenshteinDistance(t *testing.T) {
-	// No valid inputs => no suggestions at all (no bare "valid references: ").
-	assert.Empty(t, SuggestionsOnLevenshteinDistance("foo", nil))
-
-	// Close match => did-you-mean plus the valid-references list.
-	assert.Equal(t,
-		[]string{"did you mean: `name`", "valid references: `name`, `color`"},
-		SuggestionsOnLevenshteinDistance("nam", []string{"name", "color"}),
-	)
-
-	// No close match => valid-references list only.
-	assert.Equal(t,
-		[]string{"valid references: `name`, `color`"},
-		SuggestionsOnLevenshteinDistance("zzzzz", []string{"name", "color"}),
-	)
-}

pkg/flagger/handler.go

@@ -35,7 +35,11 @@ func (handler *handler) GetFeatures(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	orgID := valuer.MustNewUUID(claims.OrgID)
+	orgID, err := valuer.NewUUID(claims.OrgID)
+	if err != nil {
+		render.Error(rw, err)
+		return
+	}
 
 	evalCtx := featuretypes.NewFlaggerEvaluationContext(orgID)
 

pkg/http/binding/binding.go

@@ -20,7 +20,6 @@ var (
 type bindBodyOptions struct {
 	DisallowUnknownFields bool
 	UseNumber             bool
-	UnknownFieldContext   string
 }
 
 type BindBodyOption func(*bindBodyOptions)
@@ -31,12 +30,6 @@ func WithDisallowUnknownFields(disallowUnknownFields bool) BindBodyOption {
 	}
 }
 
-func WithUnknownFieldContext(context string) BindBodyOption {
-	return func(options *bindBodyOptions) {
-		options.UnknownFieldContext = context
-	}
-}
-
 func WithUseNumber(useNumber bool) BindBodyOption {
 	return func(options *bindBodyOptions) {
 		options.UseNumber = useNumber

pkg/http/binding/json.go

@@ -3,8 +3,6 @@ package binding
 import (
 	"encoding/json"
 	"io"
-	"reflect"
-	"strings"
 
 	"github.com/SigNoz/signoz/pkg/errors"
 )
@@ -61,70 +59,8 @@ func (b *jsonBinding) BindBody(body io.Reader, obj any, opts ...BindBodyOption)
 				WithAdditional("value of type '" + unmarshalTypeError.Value + "' was received, try sending '" + unmarshalTypeError.Type.String() + "' instead?")
 		}
 
-		// DisallowUnknownFields surfaces a bare `json: unknown field "x"`; turn it
-		// into a structured invalid-input error with did-you-mean/valid-reference
-		// suggestions drawn from obj's own JSON field names. Gated on the strict
-		// flag so an already-structured "unknown field" error bubbling up from a
-		// nested UnmarshalJSON is passed through unchanged, not re-wrapped here with
-		// the wrong (outer) field set.
-		if bindBodyOptions.DisallowUnknownFields && strings.Contains(err.Error(), "unknown field") {
-			if field := extractUnknownField(err.Error()); field != "" {
-				message := "unknown field %q"
-				if bindBodyOptions.UnknownFieldContext != "" {
-					message = "unknown field %q in " + bindBodyOptions.UnknownFieldContext
-				}
-
-				return errors.
-					NewInvalidInputf(errors.CodeInvalidInput, message, field).
-					WithSuggestions(errors.SuggestionsOnLevenshteinDistance(field, JSONFieldNames(obj))...)
-			}
-		}
-
 		return err
 	}
 
 	return nil
 }
-
-// JSONFieldNames returns the JSON field names of a struct (or pointer to one),
-// skipping fields tagged "-" or without a json tag.
-func JSONFieldNames(v any) []string {
-	var fields []string
-
-	t := reflect.TypeOf(v)
-	if t.Kind() == reflect.Pointer {
-		t = t.Elem()
-	}
-
-	if t.Kind() != reflect.Struct {
-		return fields
-	}
-
-	for i := 0; i < t.NumField(); i++ {
-		field := t.Field(i)
-		jsonTag := field.Tag.Get("json")
-
-		if jsonTag == "" || jsonTag == "-" {
-			continue
-		}
-
-		fieldName := strings.Split(jsonTag, ",")[0]
-		if fieldName != "" {
-			fields = append(fields, fieldName)
-		}
-	}
-
-	return fields
-}
-
-// extractUnknownField pulls fieldname out of a `json: unknown field "fieldname"`
-// decoder message, or returns "" when the message has no quoted field.
-func extractUnknownField(errMsg string) string {
-	parts := strings.Split(errMsg, `"`)
-
-	if len(parts) >= 2 {
-		return parts[1]
-	}
-
-	return ""
-}

pkg/http/binding/json_test.go

@@ -58,89 +58,11 @@ func TestJSONBinding_BindBodyErrors(t *testing.T) {
 			err := JSON.BindBody(strings.NewReader(testCase.body), testCase.obj, testCase.opts...)
 			assert.Error(t, err)
 
-			typ, c, m, _, _, _ := errors.Unwrapb(err)
+			typ, c, m, _, _, a := errors.Unwrapb(err)
 			assert.Equal(t, errors.TypeInvalidInput, typ)
 			assert.Equal(t, testCase.code, c)
 			assert.Equal(t, testCase.message, m)
-
-			messages := []string{}
-			for _, additional := range errors.AsJSON(err).Errors {
-				messages = append(messages, additional.Message)
-			}
-			assert.ElementsMatch(t, testCase.a, messages)
+			assert.ElementsMatch(t, testCase.a, a)
 		})
 	}
 }
-
-type widget struct {
-	Name  string `json:"name"`
-	Color string `json:"color"`
-}
-
-func TestJSONBinding_BindBody_UnknownFieldSuggestions(t *testing.T) {
-	testCases := []struct {
-		name        string
-		body        string
-		opts        []BindBodyOption
-		message     string
-		suggestions []string
-	}{
-		{
-			name:        "NoNearMatch",
-			body:        `{"shape":"round"}`,
-			opts:        []BindBodyOption{WithDisallowUnknownFields(true)},
-			message:     `unknown field "shape"`,
-			suggestions: []string{"valid references: `name`, `color`"},
-		},
-		{
-			name:        "WithContext",
-			body:        `{"shape":"round"}`,
-			opts:        []BindBodyOption{WithDisallowUnknownFields(true), WithUnknownFieldContext("widget spec")},
-			message:     `unknown field "shape" in widget spec`,
-			suggestions: []string{"valid references: `name`, `color`"},
-		},
-		{
-			name:        "NearMatch",
-			body:        `{"nam":"x"}`,
-			opts:        []BindBodyOption{WithDisallowUnknownFields(true)},
-			message:     `unknown field "nam"`,
-			suggestions: []string{"did you mean: `name`", "valid references: `name`, `color`"},
-		},
-	}
-
-	for _, testCase := range testCases {
-		t.Run(testCase.name, func(t *testing.T) {
-			err := JSON.BindBody(strings.NewReader(testCase.body), &widget{}, testCase.opts...)
-			assert.Error(t, err)
-
-			_, c, m, _, _, _ := errors.Unwrapb(err)
-
-			if testCase.message != "" {
-				assert.Equal(t, errors.CodeInvalidInput, c)
-				assert.Equal(t, testCase.message, m)
-			}
-
-			assert.Equal(t, testCase.suggestions, errors.AsJSON(err).Suggestions)
-		})
-	}
-}
-
-type structuredUnknownField struct{}
-
-func (*structuredUnknownField) UnmarshalJSON([]byte) error {
-	return errors.
-		NewInvalidInputf(errors.CodeInvalidInput, "unknown field %q in inner spec", "foo").
-		WithSuggestions("did you mean: `bar`")
-}
-
-// A non-strict BindBody must pass through an already-structured "unknown field"
-// error returned by a nested UnmarshalJSON, not re-wrap it with the outer field set.
-func TestJSONBinding_BindBody_PassesThroughStructuredUnknownField(t *testing.T) {
-	err := JSON.BindBody(strings.NewReader(`{}`), &structuredUnknownField{})
-	assert.Error(t, err)
-
-	_, c, m, _, _, _ := errors.Unwrapb(err)
-	assert.Equal(t, errors.CodeInvalidInput, c)
-	assert.Equal(t, `unknown field "foo" in inner spec`, m)
-	assert.Equal(t, []string{"did you mean: `bar`"}, errors.AsJSON(err).Suggestions)
-}

pkg/http/handler/handler.go

@@ -113,11 +113,9 @@ func (handler *handler) ServeOpenAPI(opCtx openapi.OperationContext) {
 			openapi.WithHTTPStatus(handler.openAPIDef.SuccessStatusCode),
 		)
 	} else {
-		// No response body (e.g. 204 No Content): omit the content type so the
-		// spec doesn't declare a body for a bodyless response, which would make
-		// clients try to decode an empty payload.
 		opCtx.AddRespStructure(
 			nil,
+			openapi.WithContentType(handler.openAPIDef.ResponseContentType),
 			openapi.WithHTTPStatus(handler.openAPIDef.SuccessStatusCode),
 		)
 	}

pkg/querier/api.go

@@ -11,7 +11,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/analytics"
 	"github.com/SigNoz/signoz/pkg/errors"
 	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/http/binding"
 	"github.com/SigNoz/signoz/pkg/http/render"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
@@ -46,7 +45,7 @@ func (handler *handler) QueryRange(rw http.ResponseWriter, req *http.Request) {
 	}
 
 	var queryRangeRequest qbtypes.QueryRangeRequest
-	if err := binding.JSON.BindBody(req.Body, &queryRangeRequest); err != nil {
+	if err := json.NewDecoder(req.Body).Decode(&queryRangeRequest); err != nil {
 		render.Error(rw, err)
 		return
 	}
@@ -187,7 +186,7 @@ func (handler *handler) QueryRawStream(rw http.ResponseWriter, req *http.Request
 func (handler *handler) ReplaceVariables(rw http.ResponseWriter, req *http.Request) {
 
 	var queryRangeRequest qbtypes.QueryRangeRequest
-	if err := binding.JSON.BindBody(req.Body, &queryRangeRequest); err != nil {
+	if err := json.NewDecoder(req.Body).Decode(&queryRangeRequest); err != nil {
 		render.Error(rw, err)
 		return
 	}

pkg/querier/collect.go

@@ -1,65 +0,0 @@
-package querier
-
-import (
-	"context"
-	"fmt"
-	"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/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)
-
-	var (
-		traces           uint64
-		tracesLastSeenAt time.Time
-	)
-	if err := q.telemetryStore.ClickhouseDB().QueryRow(ctx, fmt.Sprintf("SELECT COUNT(*), max(timestamp) FROM %s", tracesTable)).Scan(&traces, &tracesLastSeenAt); err == nil {
-		stats["telemetry.traces.count"] = traces
-		if tracesLastSeenAt.Unix() != 0 {
-			stats["telemetry.traces.last_observed.time"] = tracesLastSeenAt.UTC()
-			stats["telemetry.traces.last_observed.time_unix"] = tracesLastSeenAt.Unix()
-		}
-	} else {
-		q.logger.DebugContext(ctx, "failed to collect traces stats", errors.Attr(err))
-	}
-
-	var (
-		logs           uint64
-		logsLastSeenAt time.Time
-	)
-	if err := q.telemetryStore.ClickhouseDB().QueryRow(ctx, fmt.Sprintf("SELECT COUNT(*), fromUnixTimestamp64Nano(max(timestamp)) FROM %s", logsTable)).Scan(&logs, &logsLastSeenAt); err == nil {
-		stats["telemetry.logs.count"] = logs
-		if logsLastSeenAt.Unix() != 0 {
-			stats["telemetry.logs.last_observed.time"] = logsLastSeenAt.UTC()
-			stats["telemetry.logs.last_observed.time_unix"] = logsLastSeenAt.Unix()
-		}
-	} else {
-		q.logger.DebugContext(ctx, "failed to collect logs stats", errors.Attr(err))
-	}
-
-	var (
-		metrics           uint64
-		metricsLastSeenAt time.Time
-	)
-	if err := q.telemetryStore.ClickhouseDB().QueryRow(ctx, fmt.Sprintf("SELECT COUNT(*), toDateTime(max(unix_milli) / 1000) FROM %s", metricsTable)).Scan(&metrics, &metricsLastSeenAt); err == nil {
-		stats["telemetry.metrics.count"] = metrics
-		if metricsLastSeenAt.Unix() != 0 {
-			stats["telemetry.metrics.last_observed.time"] = metricsLastSeenAt.UTC()
-			stats["telemetry.metrics.last_observed.time_unix"] = metricsLastSeenAt.Unix()
-		}
-	} else {
-		q.logger.DebugContext(ctx, "failed to collect metrics stats", errors.Attr(err))
-	}
-
-	return stats, nil
-}

pkg/querier/interfaces.go

@@ -4,7 +4,6 @@ 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"
 )
@@ -13,7 +12,6 @@ import (
 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
 }
 
 // BucketCache is the interface for bucket-based caching.

pkg/querybuilder/fallback_expr.go

@@ -32,7 +32,7 @@ func CollisionHandledFinalExpr(
 
 	if requiredDataType != telemetrytypes.FieldDataTypeString &&
 		requiredDataType != telemetrytypes.FieldDataTypeFloat64 {
-		return "", nil, errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported data type %s", requiredDataType)
+		return "", nil, errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "unsupported data type %s", requiredDataType)
 	}
 
 	var dummyValue any
@@ -81,8 +81,14 @@ func CollisionHandledFinalExpr(
 			// - it is not a static field
 			// - the next best thing to do is see if there is a typo
 			// and suggest a correction
-			wrappedErr := errors.WithSuggestiveAdditionalf(fieldForErr, errors.SuggestionsOnLevenshteinDistance(field.Name, maps.Keys(keys)), "field `%s` not found", field.Name)
-			return "", nil, wrappedErr
+			correction, found := telemetrytypes.SuggestCorrection(field.Name, maps.Keys(keys))
+			if found {
+				// we found a close match, in the error message send the suggestion
+				return "", nil, errors.WithAdditionalf(fieldForErr, "%s", correction)
+			} else {
+				// not even a close match, return an error
+				return "", nil, errors.WithAdditionalf(fieldForErr, "field `%s` not found", field.Name)
+			}
 		} else {
 			for _, key := range keysForField {
 				err := addCondition(key)

pkg/querybuilder/having_expression_validator.go

@@ -294,30 +294,24 @@ func (r *HavingExpressionRewriter) rewriteAndValidate(expression string) (string
 			validKeys = append(validKeys, k)
 		}
 		sort.Strings(validKeys)
-		// Each suggestion is a self-describing string prefixed with either
-		// "did you mean: " (the full corrected expression) or "valid references: "
-		// (the set of valid references).
-		var suggestions []string
+		additional := []string{"Valid references are: [" + strings.Join(validKeys, ", ") + "]"}
 		if len(v.invalid) == 1 {
 			inv := v.invalid[0]
-			suggestions = errors.SuggestionsFromFunc(func() string {
-				match, ok := errors.ClosestLevenshteinMatch(inv, validKeys)
-				if !ok || strings.Contains(original, inv+"(") || strings.Contains(match, "(") {
-					return ""
-				}
-				return strings.ReplaceAll(original, inv, match)
-			})
+			// Only suggest for plain identifier typos, not for unresolved function
+			// calls: a function call will appear as "name(" in the expression, and
+			// the closest valid key may itself contain "(" (e.g. "sum(a)"), making
+			// a simple string substitution produce a corrupt expression.
+			isFuncCall := strings.Contains(original, inv+"(")
+			if match, dist := closestMatch(inv, validKeys); !isFuncCall && !strings.Contains(match, "(") && dist <= 3 {
+				corrected := strings.ReplaceAll(original, inv, match)
+				additional = append(additional, "Suggestion: `"+corrected+"`")
+			}
 		}
-
-		suggestions = append(suggestions, errors.ValidReferences(validKeys...))
-		havingErr := errors.NewInvalidInputf(
+		return "", errors.NewInvalidInputf(
 			errors.CodeInvalidInput,
 			"Invalid references in `Having` expression: [%s]",
 			strings.Join(v.invalid, ", "),
-		).WithAdditional(
-			"Valid references are: [" + strings.Join(validKeys, ", ") + "]",
-		).WithSuggestions(suggestions...)
-		return "", havingErr
+		).WithAdditional(additional...)
 	}
 
 	// Layer 3 – ANTLR syntax errors. We parse the original expression, so error messages
@@ -330,22 +324,21 @@ func (r *HavingExpressionRewriter) rewriteAndValidate(expression string) (string
 				msgs = append(msgs, m)
 			}
 		}
-		havingErr := errors.NewInvalidInputf(
+		detail := strings.Join(msgs, "; ")
+		if detail == "" {
+			detail = "check the expression syntax"
+		}
+		additional := []string{detail}
+		// For single-error expressions, try to produce an actionable suggestion.
+		if len(allSyntaxErrors) == 1 {
+			if s := havingSuggestion(allSyntaxErrors[0], original); s != "" {
+				additional = append(additional, "Suggestion: `"+s+"`")
+			}
+		}
+		return "", errors.NewInvalidInputf(
 			errors.CodeInvalidInput,
 			"Syntax error in `Having` expression",
-		)
-
-		// A single syntax error can carry an actionable suggestion on the same detail;
-		// multiple errors are surfaced as one additional detail each. If the parser
-		// produced no message (rare), the top-level message stands on its own.
-		if len(allSyntaxErrors) == 1 && len(msgs) == 1 {
-			suggestions := errors.SuggestionsFromFunc(func() string {
-				return havingSuggestion(allSyntaxErrors[0], original)
-			})
-
-			return "", havingErr.WithSuggestiveAdditional(msgs[0], suggestions...)
-		}
-		return "", havingErr.WithAdditional(msgs...)
+		).WithAdditional(additional...)
 	}
 
 	return result, nil
@@ -455,6 +448,42 @@ func hasUnclosedBracket(s string) bool {
 	return count > 0
 }
 
+// closestMatch returns the element of candidates with the smallest Levenshtein
+// distance to query, along with that distance.
+func closestMatch(query string, candidates []string) (string, int) {
+	best, bestDist := "", -1
+	for _, c := range candidates {
+		if d := levenshtein(query, c); bestDist < 0 || d < bestDist {
+			best, bestDist = c, d
+		}
+	}
+	return best, bestDist
+}
+
+// levenshtein computes the edit distance between a and b.
+func levenshtein(a, b string) int {
+	ra, rb := []rune(a), []rune(b)
+	la, lb := len(ra), len(rb)
+	row := make([]int, lb+1)
+	for j := range row {
+		row[j] = j
+	}
+	for i := 1; i <= la; i++ {
+		prev := row[0]
+		row[0] = i
+		for j := 1; j <= lb; j++ {
+			tmp := row[j]
+			if ra[i-1] == rb[j-1] {
+				row[j] = prev
+			} else {
+				row[j] = 1 + min(prev, min(row[j], row[j-1]))
+			}
+			prev = tmp
+		}
+	}
+	return row[lb]
+}
+
 // endsWithComparisonOp reports whether s ends with a comparison operator token
 // (longer operators are checked first to avoid ">=" being matched by ">").
 func endsWithComparisonOp(s string) bool {

pkg/querybuilder/having_rewriter_test.go

@@ -18,39 +18,14 @@ func toTraceAggregations(logs []qbtypes.LogAggregation) []qbtypes.TraceAggregati
 	return out
 }
 
-// additionalMessages extracts the message of each additional detail on err, so tests
-// can compare against a plain []string.
-func additionalMessages(err error) []string {
-	var msgs []string
-	for _, e := range errors.AsJSON(err).Errors {
-		msgs = append(msgs, e.Message)
-	}
-	return msgs
-}
-
-// allSuggestions collects suggestions from both the error-wide list and every additional
-// detail, so tests can assert suggestions regardless of where they are attached.
-func allSuggestions(err error) []string {
-	j := errors.AsJSON(err)
-	s := append([]string{}, j.Suggestions...)
-	for _, e := range j.Errors {
-		s = append(s, e.Suggestions...)
-	}
-	if len(s) == 0 {
-		return nil
-	}
-	return s
-}
-
 type logsAndTracesTestCase struct {
-	name            string
-	expression      string
-	aggregations    []qbtypes.LogAggregation
-	wantExpression  string
-	wantErr         bool
-	wantErrMsg      string
-	wantAdditional  []string
-	wantSuggestions []string
+	name           string
+	expression     string
+	aggregations   []qbtypes.LogAggregation
+	wantExpression string
+	wantErr        bool
+	wantErrMsg     string
+	wantAdditional []string
 }
 
 func runLogsAndTracesTests(t *testing.T, tests []logsAndTracesTestCase) {
@@ -65,12 +40,12 @@ func runLogsAndTracesTests(t *testing.T, tests []logsAndTracesTestCase) {
 			if tt.wantErr {
 				require.Error(t, errLogs)
 				assert.ErrorContains(t, errLogs, tt.wantErrMsg)
-				assert.Equal(t, tt.wantAdditional, additionalMessages(errLogs))
-				assert.Equal(t, tt.wantSuggestions, allSuggestions(errLogs))
+				_, _, _, _, _, additionalLogs := errors.Unwrapb(errLogs)
+				assert.Equal(t, tt.wantAdditional, additionalLogs)
 				require.Error(t, errTraces)
 				assert.ErrorContains(t, errTraces, tt.wantErrMsg)
-				assert.Equal(t, tt.wantAdditional, additionalMessages(errTraces))
-				assert.Equal(t, tt.wantSuggestions, allSuggestions(errTraces))
+				_, _, _, _, _, additionalTraces := errors.Unwrapb(errTraces)
+				assert.Equal(t, tt.wantAdditional, additionalTraces)
 			} else {
 				require.NoError(t, errLogs)
 				assert.Equal(t, tt.wantExpression, gotLogs)
@@ -315,10 +290,9 @@ func TestRewriteForLogsAndTraces_BooleanOperators(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()", Alias: "total_logs"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Syntax error in `Having` expression",
-			wantAdditional:  []string{"line 1:20 expecting one of {'*', '+', '-', (, ), AND, IDENTIFIER, NOT, number, string} but got EOF"},
-			wantSuggestions: []string{"did you mean: `total_logs > 100`"},
+			wantErr:        true,
+			wantErrMsg:     "Syntax error in `Having` expression",
+			wantAdditional: []string{"line 1:20 expecting one of {'*', '+', '-', (, ), AND, IDENTIFIER, NOT, number, string} but got EOF", "Suggestion: `total_logs > 100`"},
 		},
 		{
 			name:       "dangling OR at start",
@@ -326,10 +300,9 @@ func TestRewriteForLogsAndTraces_BooleanOperators(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()", Alias: "total_logs"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Syntax error in `Having` expression",
-			wantAdditional:  []string{"line 1:0 expecting one of {'*', '+', '-', (, ), AND, IDENTIFIER, NOT, number, string} but got 'OR'"},
-			wantSuggestions: []string{"did you mean: `total_logs > 100`"},
+			wantErr:        true,
+			wantErrMsg:     "Syntax error in `Having` expression",
+			wantAdditional: []string{"line 1:0 expecting one of {'*', '+', '-', (, ), AND, IDENTIFIER, NOT, number, string} but got 'OR'", "Suggestion: `total_logs > 100`"},
 		},
 		{
 			name:       "dangling OR at end",
@@ -337,10 +310,9 @@ func TestRewriteForLogsAndTraces_BooleanOperators(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()", Alias: "total"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Syntax error in `Having` expression",
-			wantAdditional:  []string{"line 1:14 expecting one of {'*', '+', '-', (, ), AND, IDENTIFIER, NOT, number, string} but got EOF"},
-			wantSuggestions: []string{"did you mean: `total > 100`"},
+			wantErr:        true,
+			wantErrMsg:     "Syntax error in `Having` expression",
+			wantAdditional: []string{"line 1:14 expecting one of {'*', '+', '-', (, ), AND, IDENTIFIER, NOT, number, string} but got EOF", "Suggestion: `total > 100`"},
 		},
 		{
 			name:       "consecutive AND operators",
@@ -590,10 +562,9 @@ func TestRewriteForLogsAndTraces_InOperator(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()", Alias: "total"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [ghost]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, count(), total]"},
-			wantSuggestions: []string{"valid references: `__result`, `__result0`, `count()`, `total`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [ghost]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, count(), total]"},
 		},
 		{
 			name:       "IN with end bracked missing",
@@ -601,10 +572,9 @@ func TestRewriteForLogsAndTraces_InOperator(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Syntax error in `Having` expression",
-			wantAdditional:  []string{"line 1:19 expecting one of {]} but got EOF"},
-			wantSuggestions: []string{"did you mean: `count() IN [1, 2, 3]`"},
+			wantErr:        true,
+			wantErrMsg:     "Syntax error in `Having` expression",
+			wantAdditional: []string{"line 1:19 expecting one of {]} but got EOF", "Suggestion: `count() IN [1, 2, 3]`"},
 		},
 		{
 			name:       "IN with end paran missing",
@@ -612,10 +582,9 @@ func TestRewriteForLogsAndTraces_InOperator(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Syntax error in `Having` expression",
-			wantAdditional:  []string{"line 1:19 expecting one of {)} but got EOF"},
-			wantSuggestions: []string{"did you mean: `count() IN (1, 2, 3)`"},
+			wantErr:        true,
+			wantErrMsg:     "Syntax error in `Having` expression",
+			wantAdditional: []string{"line 1:19 expecting one of {)} but got EOF", "Suggestion: `count() IN (1, 2, 3)`"},
 		},
 	})
 }
@@ -652,10 +621,9 @@ func TestRewriteForLogsAndTraces_ErrorInvalidReferences(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()", Alias: "total"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [unknown_alias]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, count(), total]"},
-			wantSuggestions: []string{"valid references: `__result`, `__result0`, `count()`, `total`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [unknown_alias]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, count(), total]"},
 		},
 		{
 			name:       "typo in identifier suggests closest match",
@@ -663,10 +631,9 @@ func TestRewriteForLogsAndTraces_ErrorInvalidReferences(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()", Alias: "total"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [totol]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, count(), total]"},
-			wantSuggestions: []string{"did you mean: `total > 100`", "valid references: `__result`, `__result0`, `count()`, `total`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [totol]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, count(), total]", "Suggestion: `total > 100`"},
 		},
 		{
 			name:       "expression not in column map",
@@ -674,10 +641,9 @@ func TestRewriteForLogsAndTraces_ErrorInvalidReferences(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [sum]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, count()]"},
-			wantSuggestions: []string{"valid references: `__result`, `__result0`, `count()`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [sum]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, count()]"},
 		},
 		{
 			name:       "one valid one invalid reference",
@@ -685,10 +651,9 @@ func TestRewriteForLogsAndTraces_ErrorInvalidReferences(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()", Alias: "total"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [ghost]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, count(), total]"},
-			wantSuggestions: []string{"valid references: `__result`, `__result0`, `count()`, `total`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [ghost]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, count(), total]"},
 		},
 		{
 			name:       "__result ambiguous with multiple aggregations",
@@ -697,10 +662,9 @@ func TestRewriteForLogsAndTraces_ErrorInvalidReferences(t *testing.T) {
 				{Expression: "count()"},
 				{Expression: "sum(bytes)"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [__result]",
-			wantAdditional:  []string{"Valid references are: [__result0, __result1, count(), sum(bytes)]"},
-			wantSuggestions: []string{"did you mean: `__result0 > 100`", "valid references: `__result0`, `__result1`, `count()`, `sum(bytes)`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [__result]",
+			wantAdditional: []string{"Valid references are: [__result0, __result1, count(), sum(bytes)]", "Suggestion: `__result0 > 100`"},
 		},
 		{
 			name:       "out-of-range __result_N index",
@@ -708,10 +672,9 @@ func TestRewriteForLogsAndTraces_ErrorInvalidReferences(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [__result_9]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, count()]"},
-			wantSuggestions: []string{"did you mean: `__result > 100`", "valid references: `__result`, `__result0`, `count()`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [__result_9]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, count()]", "Suggestion: `__result > 100`"},
 		},
 		{
 			name:       "__result_1 out of range for single aggregation",
@@ -719,10 +682,9 @@ func TestRewriteForLogsAndTraces_ErrorInvalidReferences(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [__result_1]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, count()]"},
-			wantSuggestions: []string{"did you mean: `__result > 100`", "valid references: `__result`, `__result0`, `count()`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [__result_1]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, count()]", "Suggestion: `__result > 100`"},
 		},
 		{
 			name:       "cascaded function calls",
@@ -730,10 +692,9 @@ func TestRewriteForLogsAndTraces_ErrorInvalidReferences(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [sum]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, count()]"},
-			wantSuggestions: []string{"valid references: `__result`, `__result0`, `count()`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [sum]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, count()]"},
 		},
 		{
 			name:       "function call with multiple args not in column map",
@@ -741,10 +702,9 @@ func TestRewriteForLogsAndTraces_ErrorInvalidReferences(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "sum(a)"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [sum]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, sum(a)]"},
-			wantSuggestions: []string{"valid references: `__result`, `__result0`, `sum(a)`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [sum]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, sum(a)]"},
 		},
 		{
 			name:       "unquoted string value treated as unknown identifier",
@@ -752,10 +712,9 @@ func TestRewriteForLogsAndTraces_ErrorInvalidReferences(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "sum(bytes)"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [xyz]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, sum(bytes)]"},
-			wantSuggestions: []string{"valid references: `__result`, `__result0`, `sum(bytes)`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [xyz]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, sum(bytes)]"},
 		},
 	})
 }
@@ -772,10 +731,9 @@ func TestRewriteForLogsAndTraces_ErrorSyntax(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()", Alias: "total_logs"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Syntax error in `Having` expression",
-			wantAdditional:  []string{"line 1:7 expecting one of {'*', '+', '-', (, ), IDENTIFIER, number, string} but got EOF"},
-			wantSuggestions: []string{"did you mean: `count() > 0`"},
+			wantErr:        true,
+			wantErrMsg:     "Syntax error in `Having` expression",
+			wantAdditional: []string{"line 1:7 expecting one of {'*', '+', '-', (, ), IDENTIFIER, number, string} but got EOF", "Suggestion: `count() > 0`"},
 		},
 		{
 			name:       "bare identifier without comparison",
@@ -783,10 +741,9 @@ func TestRewriteForLogsAndTraces_ErrorSyntax(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()", Alias: "total_logs"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Syntax error in `Having` expression",
-			wantAdditional:  []string{"line 1:10 expecting one of {'*', '+', '-', (, ), IDENTIFIER, number, string} but got EOF"},
-			wantSuggestions: []string{"did you mean: `total_logs > 0`"},
+			wantErr:        true,
+			wantErrMsg:     "Syntax error in `Having` expression",
+			wantAdditional: []string{"line 1:10 expecting one of {'*', '+', '-', (, ), IDENTIFIER, number, string} but got EOF", "Suggestion: `total_logs > 0`"},
 		},
 		// Parenthesis mismatches
 		{
@@ -795,10 +752,9 @@ func TestRewriteForLogsAndTraces_ErrorSyntax(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()", Alias: "total_logs"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Syntax error in `Having` expression",
-			wantAdditional:  []string{"line 1:35 expecting one of {)} but got EOF"},
-			wantSuggestions: []string{"did you mean: `(total_logs > 100 AND count() < 500)`"},
+			wantErr:        true,
+			wantErrMsg:     "Syntax error in `Having` expression",
+			wantAdditional: []string{"line 1:35 expecting one of {)} but got EOF", "Suggestion: `(total_logs > 100 AND count() < 500)`"},
 		},
 		{
 			name:       "unexpected closing parenthesis",
@@ -849,7 +805,7 @@ func TestRewriteForLogsAndTraces_ErrorSyntax(t *testing.T) {
 			},
 			wantErr:        true,
 			wantErrMsg:     "Syntax error in `Having` expression",
-			wantAdditional: []string{"line 1:0 expecting one of {'*', '+', '-', (, ), AND, IDENTIFIER, NOT, number, string} but got '>'", "line 1:5 expecting one of {'*', '+', '-', (, ), IDENTIFIER, number, string} but got EOF"},
+			wantAdditional: []string{"line 1:0 expecting one of {'*', '+', '-', (, ), AND, IDENTIFIER, NOT, number, string} but got '>'; line 1:5 expecting one of {'*', '+', '-', (, ), IDENTIFIER, number, string} but got EOF"},
 		},
 		{
 			name:       "missing right operand",
@@ -857,10 +813,9 @@ func TestRewriteForLogsAndTraces_ErrorSyntax(t *testing.T) {
 			aggregations: []qbtypes.LogAggregation{
 				{Expression: "count()"},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Syntax error in `Having` expression",
-			wantAdditional:  []string{"line 1:9 expecting one of {'*', '+', '-', (, ), IDENTIFIER, number, string} but got EOF"},
-			wantSuggestions: []string{"did you mean: `count() > 0`"},
+			wantErr:        true,
+			wantErrMsg:     "Syntax error in `Having` expression",
+			wantAdditional: []string{"line 1:9 expecting one of {'*', '+', '-', (, ), IDENTIFIER, number, string} but got EOF", "Suggestion: `count() > 0`"},
 		},
 		{
 			name:       "missing comparison operator",
@@ -920,14 +875,13 @@ func TestRewriteForLogsAndTraces_ErrorSyntax(t *testing.T) {
 
 func TestRewriteForMetrics(t *testing.T) {
 	tests := []struct {
-		name            string
-		expression      string
-		aggregations    []qbtypes.MetricAggregation
-		wantExpression  string
-		wantErr         bool
-		wantErrMsg      string
-		wantAdditional  []string
-		wantSuggestions []string
+		name           string
+		expression     string
+		aggregations   []qbtypes.MetricAggregation
+		wantExpression string
+		wantErr        bool
+		wantErrMsg     string
+		wantAdditional []string
 	}{
 		// --- Happy path: reference types (time/space aggregation, __result, bare metric) ---
 		{
@@ -1027,10 +981,9 @@ func TestRewriteForMetrics(t *testing.T) {
 					SpaceAggregation: metrictypes.SpaceAggregationUnspecified,
 				},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [wrong_metric]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, sum(cpu_usage)]"},
-			wantSuggestions: []string{"valid references: `__result`, `__result0`, `sum(cpu_usage)`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [wrong_metric]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, sum(cpu_usage)]"},
 		},
 		// --- Error: string literal (not allowed in HAVING) ---
 		{
@@ -1058,10 +1011,9 @@ func TestRewriteForMetrics(t *testing.T) {
 					SpaceAggregation: metrictypes.SpaceAggregationUnspecified,
 				},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Syntax error in `Having` expression",
-			wantAdditional:  []string{"line 1:9 expecting one of {'*', '+', '-', (, ), IDENTIFIER, number, string} but got EOF"},
-			wantSuggestions: []string{"did you mean: `cpu_usage > 0`"},
+			wantErr:        true,
+			wantErrMsg:     "Syntax error in `Having` expression",
+			wantAdditional: []string{"line 1:9 expecting one of {'*', '+', '-', (, ), IDENTIFIER, number, string} but got EOF", "Suggestion: `cpu_usage > 0`"},
 		},
 		// --- Error: aggregation not in column map ---
 		{
@@ -1074,10 +1026,9 @@ func TestRewriteForMetrics(t *testing.T) {
 					SpaceAggregation: metrictypes.SpaceAggregationUnspecified,
 				},
 			},
-			wantErr:         true,
-			wantErrMsg:      "Invalid references in `Having` expression: [count]",
-			wantAdditional:  []string{"Valid references are: [__result, __result0, sum(cpu_usage)]"},
-			wantSuggestions: []string{"valid references: `__result`, `__result0`, `sum(cpu_usage)`"},
+			wantErr:        true,
+			wantErrMsg:     "Invalid references in `Having` expression: [count]",
+			wantAdditional: []string{"Valid references are: [__result, __result0, sum(cpu_usage)]"},
 		},
 	}
 
@@ -1088,8 +1039,8 @@ func TestRewriteForMetrics(t *testing.T) {
 			if tt.wantErr {
 				require.Error(t, err)
 				assert.ErrorContains(t, err, tt.wantErrMsg)
-				assert.Equal(t, tt.wantAdditional, additionalMessages(err))
-				assert.Equal(t, tt.wantSuggestions, allSuggestions(err))
+				_, _, _, _, _, additional := errors.Unwrapb(err)
+				assert.Equal(t, tt.wantAdditional, additional)
 			} else {
 				require.NoError(t, err)
 				assert.Equal(t, tt.wantExpression, got)

pkg/signoz/handler.go

@@ -49,7 +49,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/ruler"
 	"github.com/SigNoz/signoz/pkg/ruler/signozruler"
-	"github.com/SigNoz/signoz/pkg/statsreporter"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/zeus"
 )
@@ -81,7 +80,6 @@ type Handlers struct {
 	TraceDetail             tracedetail.Handler
 	RulerHandler            ruler.Handler
 	LLMPricingRuleHandler   llmpricingrule.Handler
-	StatsHandler            statsreporter.Handler
 }
 
 func NewHandlers(
@@ -99,7 +97,6 @@ func NewHandlers(
 	registryHandler factory.Handler,
 	alertmanagerService alertmanager.Alertmanager,
 	rulerService ruler.Ruler,
-	statsAggregator statsreporter.Aggregator,
 ) Handlers {
 	return Handlers{
 		SavedView:               implsavedview.NewHandler(modules.SavedView),
@@ -128,6 +125,5 @@ func NewHandlers(
 		TraceDetail:             impltracedetail.NewHandler(modules.TraceDetail),
 		RulerHandler:            signozruler.NewHandler(rulerService),
 		LLMPricingRuleHandler:   impllmpricingrule.NewHandler(modules.LLMPricingRule),
-		StatsHandler:            statsreporter.NewHandler(statsAggregator),
 	}
 }

pkg/signoz/handler_test.go

@@ -63,7 +63,7 @@ func TestNewHandlers(t *testing.T) {
 
 	querierHandler := querier.NewHandler(providerSettings, nil, nil)
 	registryHandler := factory.NewHandler(nil)
-	handlers := NewHandlers(modules, providerSettings, nil, querierHandler, nil, nil, nil, nil, nil, nil, nil, registryHandler, alertmanager, nil, nil)
+	handlers := NewHandlers(modules, providerSettings, nil, querierHandler, nil, nil, nil, nil, nil, nil, nil, registryHandler, alertmanager, nil)
 	reflectVal := reflect.ValueOf(handlers)
 	for i := 0; i < reflectVal.NumField(); i++ {
 		f := reflectVal.Field(i)

pkg/signoz/openapi.go

@@ -36,7 +36,6 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/querier"
 	"github.com/SigNoz/signoz/pkg/ruler"
-	"github.com/SigNoz/signoz/pkg/statsreporter"
 	"github.com/SigNoz/signoz/pkg/types/authtypes"
 	"github.com/SigNoz/signoz/pkg/zeus"
 	"github.com/swaggest/jsonschema-go"
@@ -84,7 +83,6 @@ func NewOpenAPI(ctx context.Context, instrumentation instrumentation.Instrumenta
 		struct{ llmpricingrule.Handler }{},
 		struct{ tracedetail.Handler }{},
 		struct{ ruler.Handler }{},
-		struct{ statsreporter.Handler }{},
 	).New(ctx, instrumentation.ToProviderSettings(), apiserver.Config{})
 	if err != nil {
 		return nil, err

pkg/signoz/provider.go

@@ -265,9 +265,9 @@ func NewSharderProviderFactories() factory.NamedMap[factory.ProviderFactory[shar
 	)
 }
 
-func NewStatsReporterProviderFactories(aggregator statsreporter.Aggregator, orgGetter organization.Getter, userGetter user.Getter, tokenizer tokenizer.Tokenizer, build version.Build, analyticsConfig analytics.Config) factory.NamedMap[factory.ProviderFactory[statsreporter.StatsReporter, statsreporter.Config]] {
+func NewStatsReporterProviderFactories(telemetryStore telemetrystore.TelemetryStore, collectors []statsreporter.StatsCollector, orgGetter organization.Getter, userGetter user.Getter, tokenizer tokenizer.Tokenizer, build version.Build, analyticsConfig analytics.Config) factory.NamedMap[factory.ProviderFactory[statsreporter.StatsReporter, statsreporter.Config]] {
 	return factory.MustNewNamedMap(
-		analyticsstatsreporter.NewFactory(aggregator, orgGetter, userGetter, tokenizer, build, analyticsConfig),
+		analyticsstatsreporter.NewFactory(telemetryStore, collectors, orgGetter, userGetter, tokenizer, build, analyticsConfig),
 		noopstatsreporter.NewFactory(),
 	)
 }
@@ -310,7 +310,6 @@ func NewAPIServerProviderFactories(orgGetter organization.Getter, authz authz.Au
 			handlers.LLMPricingRuleHandler,
 			handlers.TraceDetail,
 			handlers.RulerHandler,
-			handlers.StatsHandler,
 		),
 	)
 }

pkg/signoz/provider_test.go

@@ -85,8 +85,8 @@ func TestNewProviderFactories(t *testing.T) {
 
 		userGetter := impluser.NewGetter(impluser.NewStore(sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual), instrumentationtest.New().ToProviderSettings()), userRoleStore, flagger)
 		orgGetter := implorganization.NewGetter(implorganization.NewStore(sqlstoretest.New(sqlstore.Config{Provider: "sqlite"}, sqlmock.QueryMatcherEqual)), nil)
-		statsAggregator := statsreporter.NewAggregator(providerSettings, []statsreporter.StatsCollector{})
-		NewStatsReporterProviderFactories(statsAggregator, orgGetter, userGetter, tokenizertest.NewMockTokenizer(t), version.Build{}, analytics.Config{Enabled: true})
+		telemetryStore := telemetrystoretest.New(telemetrystore.Config{Provider: "clickhouse"}, sqlmock.QueryMatcherEqual)
+		NewStatsReporterProviderFactories(telemetryStore, []statsreporter.StatsCollector{}, orgGetter, userGetter, tokenizertest.NewMockTokenizer(t), version.Build{}, analytics.Config{Enabled: true})
 	})
 
 	assert.NotPanics(t, func() {

pkg/signoz/signoz.go

@@ -499,18 +499,14 @@ func New(
 		serviceAccount,
 		cloudIntegrationModule,
 		modules.LogsPipeline,
-		querier,
 	}
 
-	// Initialize the stats aggregator (always-on, independent of whether reporting is enabled)
-	statsAggregator := statsreporter.NewAggregator(providerSettings, statsCollectors)
-
 	// Initialize stats reporter from the available stats reporter provider factories
 	statsReporter, err := factory.NewProviderFromNamedMap(
 		ctx,
 		providerSettings,
 		config.StatsReporter,
-		NewStatsReporterProviderFactories(statsAggregator, orgGetter, userGetter, tokenizer, version.Info, config.Analytics),
+		NewStatsReporterProviderFactories(telemetrystore, statsCollectors, orgGetter, userGetter, tokenizer, version.Info, config.Analytics),
 		config.StatsReporter.Provider(),
 	)
 	if err != nil {
@@ -539,7 +535,7 @@ func New(
 
 	// Initialize all handlers for the modules
 	registryHandler := factory.NewHandler(registry)
-	handlers := NewHandlers(modules, providerSettings, analytics, querierHandler, licensing, global, flagger, gateway, telemetryMetadataStore, authz, zeus, registryHandler, alertmanager, rulerInstance, statsAggregator)
+	handlers := NewHandlers(modules, providerSettings, analytics, querierHandler, licensing, global, flagger, gateway, telemetryMetadataStore, authz, zeus, registryHandler, alertmanager, rulerInstance)
 
 	// Initialize the API server (after registry so it can access service health)
 	apiserverInstance, err := factory.NewProviderFromNamedMap(

pkg/statsreporter/aggregator.go

@@ -1,67 +0,0 @@
-package statsreporter
-
-import (
-	"context"
-	"sync"
-
-	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/factory"
-	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
-	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-// Aggregator aggregates stats from every registered StatsCollector for a single organization.
-type Aggregator interface {
-	Aggregate(ctx context.Context, orgID valuer.UUID) (map[string]any, error)
-}
-
-type aggregator struct {
-	// settings
-	settings factory.ScopedProviderSettings
-
-	// a list of collectors, used to collect stats from across the codebase
-	collectors []StatsCollector
-}
-
-func NewAggregator(providerSettings factory.ProviderSettings, collectors []StatsCollector) Aggregator {
-	settings := factory.NewScopedProviderSettings(providerSettings, "github.com/SigNoz/signoz/pkg/statsreporter")
-
-	return &aggregator{
-		settings:   settings,
-		collectors: collectors,
-	}
-}
-
-func (aggregator *aggregator) Aggregate(ctx context.Context, orgID valuer.UUID) (map[string]any, error) {
-	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
-		instrumentationtypes.CodeNamespace:    "statsreporter",
-		instrumentationtypes.CodeFunctionName: "Aggregate",
-	})
-	var wg sync.WaitGroup
-	wg.Add(len(aggregator.collectors))
-
-	stats := make(map[string]any, 0)
-	mtx := sync.Mutex{}
-
-	for _, collector := range aggregator.collectors {
-		go func(collector StatsCollector) {
-			defer wg.Done()
-
-			collectorStats, err := collector.Collect(ctx, orgID)
-			if err != nil {
-				aggregator.settings.Logger().ErrorContext(ctx, "failed to collect stats", errors.Attr(err))
-				return
-			}
-
-			mtx.Lock()
-			for k, v := range collectorStats {
-				stats[k] = v
-			}
-			mtx.Unlock()
-		}(collector)
-	}
-	wg.Wait()
-
-	return stats, nil
-}

pkg/statsreporter/analyticsstatsreporter/provider.go

@@ -3,6 +3,7 @@ package analyticsstatsreporter
 import (
 	"context"
 	"log/slog"
+	"sync"
 	"time"
 
 	"go.opentelemetry.io/otel/attribute"
@@ -15,8 +16,11 @@ import (
 	"github.com/SigNoz/signoz/pkg/modules/organization"
 	"github.com/SigNoz/signoz/pkg/modules/user"
 	"github.com/SigNoz/signoz/pkg/statsreporter"
+	"github.com/SigNoz/signoz/pkg/telemetrystore"
 	"github.com/SigNoz/signoz/pkg/tokenizer"
 	"github.com/SigNoz/signoz/pkg/types"
+	"github.com/SigNoz/signoz/pkg/types/ctxtypes"
+	"github.com/SigNoz/signoz/pkg/types/instrumentationtypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 	"github.com/SigNoz/signoz/pkg/version"
 )
@@ -28,8 +32,11 @@ type provider struct {
 	// config
 	config statsreporter.Config
 
-	// used to aggregate stats for an organization
-	aggregator statsreporter.Aggregator
+	// used to get telemetry details. srikanthcvv to move this to the querier layer
+	telemetryStore telemetrystore.TelemetryStore
+
+	// a list of collectors, used to collect stats from across the codebase
+	collectors []statsreporter.StatsCollector
 
 	// used to get organizations
 	orgGetter organization.Getter
@@ -53,9 +60,9 @@ type provider struct {
 	stopC chan struct{}
 }
 
-func NewFactory(aggregator statsreporter.Aggregator, orgGetter organization.Getter, userGetter user.Getter, tokenizer tokenizer.Tokenizer, build version.Build, analyticsConfig analytics.Config) factory.ProviderFactory[statsreporter.StatsReporter, statsreporter.Config] {
+func NewFactory(telemetryStore telemetrystore.TelemetryStore, collectors []statsreporter.StatsCollector, orgGetter organization.Getter, userGetter user.Getter, tokenizer tokenizer.Tokenizer, build version.Build, analyticsConfig analytics.Config) factory.ProviderFactory[statsreporter.StatsReporter, statsreporter.Config] {
 	return factory.NewProviderFactory(factory.MustNewName("analytics"), func(ctx context.Context, settings factory.ProviderSettings, config statsreporter.Config) (statsreporter.StatsReporter, error) {
-		return New(ctx, settings, config, aggregator, orgGetter, userGetter, tokenizer, build, analyticsConfig)
+		return New(ctx, settings, config, telemetryStore, collectors, orgGetter, userGetter, tokenizer, build, analyticsConfig)
 	})
 }
 
@@ -63,7 +70,8 @@ func New(
 	ctx context.Context,
 	providerSettings factory.ProviderSettings,
 	config statsreporter.Config,
-	aggregator statsreporter.Aggregator,
+	telemetryStore telemetrystore.TelemetryStore,
+	collectors []statsreporter.StatsCollector,
 	orgGetter organization.Getter,
 	userGetter user.Getter,
 	tokenizer tokenizer.Tokenizer,
@@ -78,16 +86,17 @@ func New(
 	}
 
 	return &provider{
-		settings:   settings,
-		config:     config,
-		aggregator: aggregator,
-		orgGetter:  orgGetter,
-		userGetter: userGetter,
-		analytics:  analytics,
-		tokenizer:  tokenizer,
-		build:      build,
-		deployment: deployment,
-		stopC:      make(chan struct{}),
+		settings:       settings,
+		config:         config,
+		telemetryStore: telemetryStore,
+		collectors:     collectors,
+		orgGetter:      orgGetter,
+		userGetter:     userGetter,
+		analytics:      analytics,
+		tokenizer:      tokenizer,
+		build:          build,
+		deployment:     deployment,
+		stopC:          make(chan struct{}),
 	}, nil
 }
 
@@ -125,12 +134,7 @@ func (provider *provider) Report(ctx context.Context) error {
 	}
 
 	for _, org := range orgs {
-		stats, err := provider.aggregator.Aggregate(ctx, org.ID)
-		if err != nil {
-			provider.settings.Logger().WarnContext(ctx, "failed to aggregate stats", errors.Attr(err), slog.Any("org_id", org.ID))
-			continue
-		}
-
+		stats := provider.collectOrg(ctx, org.ID)
 		if len(stats) == 0 {
 			provider.settings.Logger().WarnContext(ctx, "no stats collected", slog.Any("org_id", org.ID))
 			continue
@@ -200,3 +204,75 @@ func (provider *provider) Stop(ctx context.Context) error {
 
 	return nil
 }
+
+func (provider *provider) collectOrg(ctx context.Context, orgID valuer.UUID) map[string]any {
+	ctx = ctxtypes.NewContextWithCommentVals(ctx, map[string]string{
+		instrumentationtypes.CodeNamespace:    "statsreporter",
+		instrumentationtypes.CodeFunctionName: "collectOrg",
+	})
+	var wg sync.WaitGroup
+	wg.Add(len(provider.collectors))
+
+	stats := make(map[string]any, 0)
+	mtx := sync.Mutex{}
+
+	for _, collector := range provider.collectors {
+		go func(collector statsreporter.StatsCollector) {
+			defer wg.Done()
+
+			collectorStats, err := collector.Collect(ctx, orgID)
+			if err != nil {
+				provider.settings.Logger().ErrorContext(ctx, "failed to collect stats", errors.Attr(err))
+				return
+			}
+
+			mtx.Lock()
+			for k, v := range collectorStats {
+				stats[k] = v
+			}
+			mtx.Unlock()
+		}(collector)
+	}
+	wg.Wait()
+
+	var traces uint64
+	if err := provider.telemetryStore.ClickhouseDB().QueryRow(ctx, "SELECT COUNT(*) FROM signoz_traces.distributed_signoz_index_v3").Scan(&traces); err == nil {
+		stats["telemetry.traces.count"] = traces
+	}
+
+	var logs uint64
+	if err := provider.telemetryStore.ClickhouseDB().QueryRow(ctx, "SELECT COUNT(*) FROM signoz_logs.distributed_logs_v2").Scan(&logs); err == nil {
+		stats["telemetry.logs.count"] = logs
+	}
+
+	var metrics uint64
+	if err := provider.telemetryStore.ClickhouseDB().QueryRow(ctx, "SELECT COUNT(*) FROM signoz_metrics.distributed_samples_v4").Scan(&metrics); err == nil {
+		stats["telemetry.metrics.count"] = metrics
+	}
+
+	var tracesLastSeenAt time.Time
+	if err := provider.telemetryStore.ClickhouseDB().QueryRow(ctx, "SELECT max(timestamp) FROM signoz_traces.distributed_signoz_index_v3").Scan(&tracesLastSeenAt); err == nil {
+		if tracesLastSeenAt.Unix() != 0 {
+			stats["telemetry.traces.last_observed.time"] = tracesLastSeenAt.UTC()
+			stats["telemetry.traces.last_observed.time_unix"] = tracesLastSeenAt.Unix()
+		}
+	}
+
+	var logsLastSeenAt time.Time
+	if err := provider.telemetryStore.ClickhouseDB().QueryRow(ctx, "SELECT fromUnixTimestamp64Nano(max(timestamp)) FROM signoz_logs.distributed_logs_v2").Scan(&logsLastSeenAt); err == nil {
+		if logsLastSeenAt.Unix() != 0 {
+			stats["telemetry.logs.last_observed.time"] = logsLastSeenAt.UTC()
+			stats["telemetry.logs.last_observed.time_unix"] = logsLastSeenAt.Unix()
+		}
+	}
+
+	var metricsLastSeenAt time.Time
+	if err := provider.telemetryStore.ClickhouseDB().QueryRow(ctx, "SELECT toDateTime(max(unix_milli) / 1000) FROM signoz_metrics.distributed_samples_v4").Scan(&metricsLastSeenAt); err == nil {
+		if metricsLastSeenAt.Unix() != 0 {
+			stats["telemetry.metrics.last_observed.time"] = metricsLastSeenAt.UTC()
+			stats["telemetry.metrics.last_observed.time_unix"] = metricsLastSeenAt.Unix()
+		}
+	}
+
+	return stats
+}

pkg/statsreporter/handler.go

@@ -1,46 +0,0 @@
-package statsreporter
-
-import (
-	"context"
-	"net/http"
-	"time"
-
-	"github.com/SigNoz/signoz/pkg/http/render"
-	"github.com/SigNoz/signoz/pkg/types/authtypes"
-	"github.com/SigNoz/signoz/pkg/valuer"
-)
-
-type Handler interface {
-	Get(http.ResponseWriter, *http.Request)
-}
-
-type handler struct {
-	aggregator Aggregator
-}
-
-func NewHandler(aggregator Aggregator) Handler {
-	return &handler{
-		aggregator: aggregator,
-	}
-}
-
-func (handler *handler) Get(rw http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 10*time.Second)
-	defer cancel()
-
-	claims, err := authtypes.ClaimsFromContext(ctx)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	orgID := valuer.MustNewUUID(claims.OrgID)
-
-	stats, err := handler.aggregator.Aggregate(ctx, orgID)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, stats)
-}

pkg/telemetryaudit/field_mapper.go

@@ -57,14 +57,14 @@ func (m *fieldMapper) FieldFor(ctx context.Context, _, _ uint64, key *telemetryt
 		return "", err
 	}
 	if len(columns) != 1 {
-		return "", errors.NewInternalf(errors.CodeInternal, "expected exactly 1 column, got %d", len(columns))
+		return "", errors.Newf(errors.TypeInternal, errors.CodeInternal, "expected exactly 1 column, got %d", len(columns))
 	}
 	column := columns[0]
 
 	switch column.Type.GetType() {
 	case schema.ColumnTypeEnumJSON:
 		if key.FieldContext != telemetrytypes.FieldContextResource {
-			return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "only resource context fields are supported for json columns in audit, got %s", key.FieldContext.String)
+			return "", errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "only resource context fields are supported for json columns in audit, got %s", key.FieldContext.String)
 		}
 		return fmt.Sprintf("%s.`%s`::String", column.Name, key.Name), nil
 	case schema.ColumnTypeEnumLowCardinality:
@@ -109,8 +109,11 @@ func (m *fieldMapper) ColumnExpressionFor(
 				field.FieldContext = telemetrytypes.FieldContextLog
 				fieldExpression, _ = m.FieldFor(ctx, tsStart, tsEnd, field)
 			} else {
-				wrappedErr := errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "field `%s` not found", field.Name).WithSuggestions(errors.SuggestionsOnLevenshteinDistance(field.Name, maps.Keys(keys))...)
-				return "", wrappedErr
+				correction, found := telemetrytypes.SuggestCorrection(field.Name, maps.Keys(keys))
+				if found {
+					return "", errors.Wrap(err, errors.TypeInvalidInput, errors.CodeInvalidInput, correction)
+				}
+				return "", errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "field `%s` not found", field.Name)
 			}
 		} else {
 			fieldExpression, _ = m.FieldFor(ctx, tsStart, tsEnd, keysForField[0])

pkg/telemetryaudit/statement_builder_test.go

@@ -5,12 +5,12 @@ import (
 	"testing"
 	"time"
 
-	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"github.com/SigNoz/signoz/pkg/instrumentation/instrumentationtest"
 	"github.com/SigNoz/signoz/pkg/querybuilder"
 	qbtypes "github.com/SigNoz/signoz/pkg/types/querybuildertypes/querybuildertypesv5"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes/telemetrytypestest"
+	"github.com/SigNoz/signoz/pkg/flagger/flaggertest"
 	"github.com/stretchr/testify/require"
 )
 

pkg/telemetrylogs/field_mapper.go

@@ -183,7 +183,7 @@ func (m *fieldMapper) FieldFor(ctx context.Context, tsStart, tsEnd uint64, key *
 
 				exprs = append(exprs, expr)
 			default:
-				return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "only resource/body context fields are supported for json columns, got %s", key.FieldContext.String)
+				return "", errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "only resource/body context fields are supported for json columns, got %s", key.FieldContext.String)
 			}
 
 		case schema.ColumnTypeEnumLowCardinality:
@@ -223,7 +223,7 @@ func (m *fieldMapper) FieldFor(ctx context.Context, tsStart, tsEnd uint64, key *
 	} else if len(exprs) > 1 {
 		// Ensure existExpr has the same length as exprs
 		if len(existExpr) != len(exprs) {
-			return "", errors.NewInternalf(errors.CodeInternal, "length of exist exprs doesn't match to that of exprs")
+			return "", errors.New(errors.TypeInternal, errors.CodeInternal, "length of exist exprs doesn't match to that of exprs")
 		}
 		finalExprs := []string{}
 		for i, expr := range exprs {
@@ -263,8 +263,14 @@ func (m *fieldMapper) ColumnExpressionFor(
 				// - it is not a static field
 				// - the next best thing to do is see if there is a typo
 				// and suggest a correction
-				wrappedErr := errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "field `%s` not found", field.Name).WithSuggestions(errors.SuggestionsOnLevenshteinDistance(field.Name, maps.Keys(keys))...)
-				return "", wrappedErr
+				correction, found := telemetrytypes.SuggestCorrection(field.Name, maps.Keys(keys))
+				if found {
+					// we found a close match, in the error message send the suggestion
+					return "", errors.Wrap(err, errors.TypeInvalidInput, errors.CodeInvalidInput, correction)
+				} else {
+					// not even a close match, return an error
+					return "", errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "field `%s` not found", field.Name)
+				}
 			}
 		} else if len(keysForField) == 1 {
 			// we have a single key for the field, use it
@@ -289,7 +295,7 @@ func (m *fieldMapper) ColumnExpressionFor(
 func (m *fieldMapper) buildFieldForJSON(key *telemetrytypes.TelemetryFieldKey) (string, error) {
 	plan := key.JSONPlan
 	if len(plan) == 0 {
-		return "", errors.NewInvalidInputf(errors.CodeInvalidInput,
+		return "", errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput,
 			"Could not find any valid paths for: %s", key.Name)
 	}
 
@@ -344,7 +350,7 @@ func (m *fieldMapper) buildFieldForJSON(key *telemetrytypes.TelemetryFieldKey) (
 // buildArrayConcat builds the arrayConcat pattern directly from the tree structure.
 func (m *fieldMapper) buildArrayConcat(plan telemetrytypes.JSONAccessPlan) (string, error) {
 	if len(plan) == 0 {
-		return "", errors.NewInternalf(CodeGroupByPlanEmpty, "group by plan is empty while building arrayConcat")
+		return "", errors.Newf(errors.TypeInternal, CodeGroupByPlanEmpty, "group by plan is empty while building arrayConcat")
 	}
 
 	// Build arrayMap expressions for ALL available branches at the root level.
@@ -360,7 +366,7 @@ func (m *fieldMapper) buildArrayConcat(plan telemetrytypes.JSONAccessPlan) (stri
 		}
 	}
 	if len(arrayMapExpressions) == 0 {
-		return "", errors.NewInternalf(CodeArrayMapExpressionsEmpty, "array map expressions are empty while building arrayConcat")
+		return "", errors.Newf(errors.TypeInternal, CodeArrayMapExpressionsEmpty, "array map expressions are empty while building arrayConcat")
 	}
 
 	// Build the arrayConcat expression
@@ -375,12 +381,12 @@ func (m *fieldMapper) buildArrayConcat(plan telemetrytypes.JSONAccessPlan) (stri
 // buildArrayMap builds the arrayMap expression for a specific branch, handling all sub-branches.
 func (m *fieldMapper) buildArrayMap(currentNode *telemetrytypes.JSONAccessNode, branchType telemetrytypes.JSONAccessBranchType) (string, error) {
 	if currentNode == nil {
-		return "", errors.NewInternalf(CodeCurrentNodeNil, "current node is nil while building arrayMap")
+		return "", errors.Newf(errors.TypeInternal, CodeCurrentNodeNil, "current node is nil while building arrayMap")
 	}
 
 	childNode := currentNode.Branches[branchType]
 	if childNode == nil {
-		return "", errors.NewInternalf(CodeChildNodeNil, "child node is nil while building arrayMap")
+		return "", errors.Newf(errors.TypeInternal, CodeChildNodeNil, "child node is nil while building arrayMap")
 	}
 
 	// Build the array expression for this level
@@ -421,7 +427,7 @@ func (m *fieldMapper) buildArrayMap(currentNode *telemetrytypes.JSONAccessNode,
 	} else if len(nestedExpressions) > 1 {
 		nestedExpr = fmt.Sprintf("arrayConcat(%s)", strings.Join(nestedExpressions, ", "))
 	} else {
-		return "", errors.NewInternalf(CodeNestedExpressionsEmpty, "nested expressions are empty while building arrayMap")
+		return "", errors.Newf(errors.TypeInternal, CodeNestedExpressionsEmpty, "nested expressions are empty while building arrayMap")
 	}
 
 	return fmt.Sprintf("arrayMap(%s->%s, %s)", currentNode.Alias(), nestedExpr, arrayExpr), nil

pkg/telemetrylogs/filter_expr_logs_test.go

@@ -16,22 +16,6 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
-// detailContains reports whether any additional detail on err (its message or one
-// of its suggestions) contains sub.
-func detailContains(err error, sub string) bool {
-	for _, e := range errors.AsJSON(err).Errors {
-		if strings.Contains(e.Message, sub) {
-			return true
-		}
-		for _, s := range e.Suggestions {
-			if strings.Contains(s, sub) {
-				return true
-			}
-		}
-	}
-	return false
-}
-
 // TestFilterExprLogs tests a comprehensive set of query patterns for logs search.
 func TestFilterExprLogs(t *testing.T) {
 	fl := flaggertest.New(t)
@@ -2431,7 +2415,15 @@ func TestFilterExprLogs(t *testing.T) {
 				require.Equal(t, tc.expectedArgs, args)
 			} else {
 				require.Error(t, err, "Expected error for query: %s", tc.query)
-				require.True(t, detailContains(err, tc.expectedErrorContains))
+				_, _, _, _, _, a := errors.Unwrapb(err)
+				contains := false
+				for _, warn := range a {
+					if strings.Contains(warn, tc.expectedErrorContains) {
+						contains = true
+						break
+					}
+				}
+				require.True(t, contains)
 			}
 		})
 	}
@@ -2544,7 +2536,15 @@ func TestFilterExprLogsConflictNegation(t *testing.T) {
 				require.Equal(t, tc.expectedArgs, args)
 			} else {
 				require.Error(t, err, "Expected error for query: %s", tc.query)
-				require.True(t, detailContains(err, tc.expectedErrorContains))
+				_, _, _, _, _, a := errors.Unwrapb(err)
+				contains := false
+				for _, warn := range a {
+					if strings.Contains(warn, tc.expectedErrorContains) {
+						contains = true
+						break
+					}
+				}
+				require.True(t, contains)
 			}
 		})
 	}

pkg/telemetrymetadata/field_mapper.go

@@ -91,8 +91,14 @@ func (m *fieldMapper) ColumnExpressionFor(
 				// - it is not a static field
 				// - the next best thing to do is see if there is a typo
 				// and suggest a correction
-				wrappedErr := errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "field `%s` not found", field.Name).WithSuggestions(errors.SuggestionsOnLevenshteinDistance(field.Name, maps.Keys(keys))...)
-				return "", wrappedErr
+				correction, found := telemetrytypes.SuggestCorrection(field.Name, maps.Keys(keys))
+				if found {
+					// we found a close match, in the error message send the suggestion
+					return "", errors.Wrap(err, errors.TypeInvalidInput, errors.CodeInvalidInput, correction)
+				} else {
+					// not even a close match, return an error
+					return "", errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "field `%s` not found", field.Name)
+				}
 			}
 		} else if len(keysForField) == 1 {
 			// we have a single key for the field, use it

pkg/telemetrymetrics/tables.go

@@ -324,7 +324,8 @@ func AggregationColumnForSamplesTable(
 		}
 	}
 	if aggregationColumn == "" {
-		return "", errors.NewInvalidInputf(
+		return "", errors.Newf(
+			errors.TypeInvalidInput,
 			errors.CodeInvalidInput,
 			"invalid time aggregation, should be one of the following: [`latest`, `sum`, `avg`, `min`, `max`, `count`, `rate`, `increase`]",
 		)
@@ -334,7 +335,7 @@ func AggregationColumnForSamplesTable(
 
 func AggregationQueryForHistogramCountWithParams(param *metrictypes.ComparisonSpaceAggregationParam) (string, error) {
 	if param == nil {
-		return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "no aggregation param provided for histogram count")
+		return "", errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "no aggregation param provided for histogram count")
 	}
 	histogramCountThreshold := param.Threshold
 
@@ -344,7 +345,7 @@ func AggregationQueryForHistogramCountWithParams(param *metrictypes.ComparisonSp
 	case ">":
 		return fmt.Sprintf("argMax(value, toFloat64(le)) - (argMaxIf(value, toFloat64(le), toFloat64(le) <= %f) + (argMinIf(value, toFloat64(le), toFloat64(le) > %f) - argMaxIf(value, toFloat64(le), toFloat64(le) <= %f)) * (%f - maxIf(toFloat64(le), toFloat64(le) <= %f)) / (minIf(toFloat64(le), toFloat64(le) > %f) - maxIf(toFloat64(le), toFloat64(le) <= %f))) AS value", histogramCountThreshold, histogramCountThreshold, histogramCountThreshold, histogramCountThreshold, histogramCountThreshold, histogramCountThreshold, histogramCountThreshold), nil
 	default:
-		return "", errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid space aggregation operator, should be one of the following: [`<=`, `>`]")
+		return "", errors.New(errors.TypeInvalidInput, errors.CodeInvalidInput, "invalid space aggregation operator, should be one of the following: [`<=`, `>`]")
 	}
 
 }

pkg/telemetrytraces/field_mapper.go

@@ -368,8 +368,14 @@ func (m *defaultFieldMapper) ColumnExpressionFor(
 				// - it is not a static field
 				// - the next best thing to do is see if there is a typo
 				// and suggest a correction
-				wrappedErr := errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "field `%s` not found", field.Name).WithSuggestions(errors.SuggestionsOnLevenshteinDistance(field.Name, maps.Keys(keys))...)
-				return "", wrappedErr
+				correction, found := telemetrytypes.SuggestCorrection(field.Name, maps.Keys(keys))
+				if found {
+					// we found a close match, in the error message send the suggestion
+					return "", errors.Wrap(err, errors.TypeInvalidInput, errors.CodeInvalidInput, correction)
+				} else {
+					// not even a close match, return an error
+					return "", errors.Wrapf(err, errors.TypeInvalidInput, errors.CodeInvalidInput, "field `%s` not found", field.Name)
+				}
 			}
 		} else if len(keysForField) == 1 {
 			// we have a single key for the field, use it

pkg/types/cloudintegrationtypes/serviceid.go

@@ -85,19 +85,10 @@ var SupportedServices = map[CloudProviderType][]ServiceID{
 }
 
 func NewServiceID(provider CloudProviderType, service string) (ServiceID, error) {
-	// The valid set is provider-scoped (AWS and Azure expose different
-	// services), so surface it as a structured suggestion along with a
-	// closest-match correction for typos.
-	supported := SupportedServices[provider]
-	validServices := make([]string, 0, len(supported))
-	for _, s := range supported {
+	for _, s := range SupportedServices[provider] {
 		if s.StringValue() == service {
 			return s, nil
 		}
-		validServices = append(validServices, s.StringValue())
 	}
-
-	return ServiceID{}, errors.NewInvalidInputf(ErrCodeInvalidServiceID,
-		"invalid service id %q for %s cloud provider", service, provider.StringValue()).
-		WithSuggestions(errors.SuggestionsOnLevenshteinDistance(service, validServices)...)
+	return ServiceID{}, errors.NewInvalidInputf(ErrCodeInvalidServiceID, "invalid service id %q for %s cloud provider", service, provider.StringValue())
 }

pkg/types/querybuildertypes/querybuildertypesv5/builder_query.go

@@ -1,11 +1,9 @@
 package querybuildertypesv5
 
 import (
-	"bytes"
 	"fmt"
 	"slices"
 
-	"github.com/SigNoz/signoz/pkg/http/binding"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/swaggest/jsonschema-go"
@@ -163,8 +161,8 @@ func (q *QueryBuilderQuery[T]) UnmarshalJSON(data []byte) error {
 	type Alias QueryBuilderQuery[T]
 
 	var temp Alias
-	// Strict-decode the alias so unknown fields surface with field-name suggestions.
-	if err := binding.JSON.BindBody(bytes.NewReader(data), &temp, binding.WithDisallowUnknownFields(true), binding.WithUnknownFieldContext(fmt.Sprintf("query spec for %T", q))); err != nil {
+	// Use UnmarshalJSONWithContext for better error messages
+	if err := UnmarshalJSONWithContext(data, &temp, fmt.Sprintf("query spec for %T", q)); err != nil {
 		return err
 	}
 

pkg/types/querybuildertypes/querybuildertypesv5/formula.go

@@ -1,7 +1,6 @@
 package querybuildertypesv5
 
 import (
-	"bytes"
 	"fmt"
 	"math"
 	"strconv"
@@ -13,7 +12,6 @@ import (
 
 	"github.com/SigNoz/govaluate"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/binding"
 )
 
 type QueryBuilderFormula struct {
@@ -68,7 +66,7 @@ func (f QueryBuilderFormula) Copy() QueryBuilderFormula {
 func (f *QueryBuilderFormula) UnmarshalJSON(data []byte) error {
 	type Alias QueryBuilderFormula
 	var temp Alias
-	if err := binding.JSON.BindBody(bytes.NewReader(data), &temp, binding.WithDisallowUnknownFields(true), binding.WithUnknownFieldContext("formula spec")); err != nil {
+	if err := UnmarshalJSONWithContext(data, &temp, "formula spec"); err != nil {
 		return err
 	}
 	*f = QueryBuilderFormula(temp)

pkg/types/querybuildertypes/querybuildertypesv5/json_decoder.go

@@ -0,0 +1,163 @@
+package querybuildertypesv5
+
+import (
+	"bytes"
+	"encoding/json"
+	"reflect"
+	"strings"
+
+	"github.com/SigNoz/signoz/pkg/errors"
+	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
+)
+
+// UnmarshalJSONWithSuggestions unmarshals JSON data into the target struct
+// and provides field name suggestions for unknown fields.
+func UnmarshalJSONWithSuggestions(data []byte, target any) error {
+	return UnmarshalJSONWithContext(data, target, "")
+}
+
+// UnmarshalJSONWithContext unmarshals JSON with context information for better error messages.
+func UnmarshalJSONWithContext(data []byte, target any, context string) error {
+	// First, try to unmarshal with DisallowUnknownFields to catch unknown fields
+	dec := json.NewDecoder(bytes.NewReader(data))
+	dec.DisallowUnknownFields()
+
+	err := dec.Decode(target)
+	if err == nil {
+		// No error, successful unmarshal
+		return nil
+	}
+
+	// Check if it's an unknown field error
+	if strings.Contains(err.Error(), "unknown field") {
+		// Extract the unknown field name
+		unknownField := extractUnknownField(err.Error())
+		if unknownField != "" {
+			// Get valid field names from the target struct
+			validFields := getJSONFieldNames(target)
+
+			// Build error message with context
+			errorMsg := "unknown field %q"
+			if context != "" {
+				errorMsg = "unknown field %q in " + context
+			}
+
+			// Find closest match with max distance of 3 (reasonable for typos)
+			if suggestion, found := telemetrytypes.SuggestCorrection(unknownField, validFields); found {
+				return errors.NewInvalidInputf(
+					errors.CodeInvalidInput,
+					errorMsg,
+					unknownField,
+				).WithAdditional(
+					suggestion,
+				)
+			}
+
+			// No good suggestion found
+			return errors.NewInvalidInputf(
+				errors.CodeInvalidInput,
+				errorMsg,
+				unknownField,
+			).WithAdditional(
+				"Valid fields are: " + strings.Join(validFields, ", "),
+			)
+		}
+	}
+
+	// Return the original error if it's not an unknown field error
+	return errors.NewInvalidInputf(errors.CodeInvalidInput, "invalid JSON: %v", err)
+}
+
+// extractUnknownField extracts the field name from an unknown field error message.
+func extractUnknownField(errMsg string) string {
+	// The error message format is: json: unknown field "fieldname"
+	parts := strings.Split(errMsg, `"`)
+	if len(parts) >= 2 {
+		return parts[1]
+	}
+	return ""
+}
+
+// getJSONFieldNames extracts all JSON field names from a struct.
+func getJSONFieldNames(v any) []string {
+	var fields []string
+
+	t := reflect.TypeOf(v)
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+	}
+
+	if t.Kind() != reflect.Struct {
+		return fields
+	}
+
+	for i := 0; i < t.NumField(); i++ {
+		field := t.Field(i)
+		jsonTag := field.Tag.Get("json")
+
+		if jsonTag == "" || jsonTag == "-" {
+			continue
+		}
+
+		// Extract the field name from the JSON tag
+		fieldName := strings.Split(jsonTag, ",")[0]
+		if fieldName != "" {
+			fields = append(fields, fieldName)
+		}
+	}
+
+	return fields
+}
+
+// wrapUnmarshalError wraps UnmarshalJSONWithContext errors with appropriate context
+// It preserves errors that already have additional context or unknown field errors.
+func wrapUnmarshalError(err error, errorFormat string, args ...interface{}) error {
+	if err == nil {
+		return nil
+	}
+
+	// If it's already one of our wrapped errors with additional context, return as-is
+	_, _, _, _, _, additionals := errors.Unwrapb(err)
+	if len(additionals) > 0 {
+		return err
+	}
+
+	// Preserve helpful error messages about unknown fields
+	if strings.Contains(err.Error(), "unknown field") {
+		return err
+	}
+
+	// Wrap with the provided error format
+	return errors.NewInvalidInputf(
+		errors.CodeInvalidInput,
+		errorFormat,
+		args...,
+	)
+}
+
+// wrapValidationError rewraps validation errors with context while preserving additional hints
+// It extracts the inner message from the error and creates a new error with the provided format
+// The innerMsg is automatically appended to the args for formatting.
+func wrapValidationError(err error, contextIdentifier string, errorFormat string) error {
+	if err == nil {
+		return nil
+	}
+
+	// Extract the underlying error details
+	_, _, innerMsg, _, _, additionals := errors.Unwrapb(err)
+
+	// Create a new error with the provided format
+	newErr := errors.NewInvalidInputf(
+		errors.CodeInvalidInput,
+		errorFormat,
+		contextIdentifier,
+		innerMsg,
+	)
+
+	// Add any additional context from the inner error
+	if len(additionals) > 0 {
+		newErr = newErr.WithAdditional(additionals...)
+	}
+
+	return newErr
+}

pkg/types/querybuildertypes/querybuildertypesv5/qb.go

@@ -11,10 +11,10 @@ import (
 
 var (
 	ErrColumnNotFound      = errors.Newf(errors.TypeNotFound, errors.CodeNotFound, "field not found")
-	ErrBetweenValues       = errors.NewInvalidInputf(errors.CodeInvalidInput, "(not) between operator requires two values")
-	ErrBetweenValuesType   = errors.NewInvalidInputf(errors.CodeInvalidInput, "(not) between operator requires two values of the number type")
-	ErrInValues            = errors.NewInvalidInputf(errors.CodeInvalidInput, "(not) in operator requires a list of values")
-	ErrUnsupportedOperator = errors.NewInvalidInputf(errors.CodeInvalidInput, "unsupported operator")
+	ErrBetweenValues       = errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "(not) between operator requires two values")
+	ErrBetweenValuesType   = errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "(not) between operator requires two values of the number type")
+	ErrInValues            = errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "(not) in operator requires a list of values")
+	ErrUnsupportedOperator = errors.Newf(errors.TypeInvalidInput, errors.CodeInvalidInput, "unsupported operator")
 )
 
 type JsonKeyToFieldFunc func(context.Context, *telemetrytypes.TelemetryFieldKey, FilterOperator, any) (string, any)

pkg/types/querybuildertypes/querybuildertypesv5/req.go

@@ -1,13 +1,11 @@
 package querybuildertypesv5
 
 import (
-	"bytes"
 	"encoding/json"
 	"strings"
 
 	"github.com/SigNoz/govaluate"
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/binding"
 	"github.com/SigNoz/signoz/pkg/types/metrictypes"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
@@ -92,7 +90,7 @@ func (q *QueryEnvelope) UnmarshalJSON(data []byte) error {
 		Type QueryType       `json:"type"`
 		Spec json.RawMessage `json:"spec"`
 	}
-	if err := binding.JSON.BindBody(bytes.NewReader(data), &shadow, binding.WithDisallowUnknownFields(true)); err != nil {
+	if err := UnmarshalJSONWithSuggestions(data, &shadow); err != nil {
 		return err
 	}
 
@@ -109,39 +107,40 @@ func (q *QueryEnvelope) UnmarshalJSON(data []byte) error {
 
 	case QueryTypeFormula:
 		var spec QueryBuilderFormula
-		if err := json.Unmarshal(shadow.Spec, &spec); err != nil {
-			return err
+		// TODO(srikanthccv): use json.Unmarshal here after implementing custom unmarshaler for QueryBuilderFormula
+		if err := UnmarshalJSONWithContext(shadow.Spec, &spec, "formula spec"); err != nil {
+			return wrapUnmarshalError(err, "invalid formula spec: %v", err)
 		}
 		q.Spec = spec
 
 	case QueryTypeJoin:
 		var spec QueryBuilderJoin
 		// TODO(srikanthccv): use json.Unmarshal here after implementing custom unmarshaler for QueryBuilderJoin
-		if err := binding.JSON.BindBody(bytes.NewReader(shadow.Spec), &spec, binding.WithDisallowUnknownFields(true), binding.WithUnknownFieldContext("join spec")); err != nil {
-			return err
+		if err := UnmarshalJSONWithContext(shadow.Spec, &spec, "join spec"); err != nil {
+			return wrapUnmarshalError(err, "invalid join spec: %v", err)
 		}
 		q.Spec = spec
 
 	case QueryTypeTraceOperator:
 		var spec QueryBuilderTraceOperator
 		if err := json.Unmarshal(shadow.Spec, &spec); err != nil {
-			return err
+			return wrapUnmarshalError(err, "invalid trace operator spec: %v", err)
 		}
 		q.Spec = spec
 
 	case QueryTypePromQL:
 		var spec PromQuery
 		// TODO(srikanthccv): use json.Unmarshal here after implementing custom unmarshaler for PromQuery
-		if err := binding.JSON.BindBody(bytes.NewReader(shadow.Spec), &spec, binding.WithDisallowUnknownFields(true), binding.WithUnknownFieldContext("PromQL spec")); err != nil {
-			return err
+		if err := UnmarshalJSONWithContext(shadow.Spec, &spec, "PromQL spec"); err != nil {
+			return wrapUnmarshalError(err, "invalid PromQL spec: %v", err)
 		}
 		q.Spec = spec
 
 	case QueryTypeClickHouseSQL:
 		var spec ClickHouseQuery
 		// TODO(srikanthccv): use json.Unmarshal here after implementing custom unmarshaler for ClickHouseQuery
-		if err := binding.JSON.BindBody(bytes.NewReader(shadow.Spec), &spec, binding.WithDisallowUnknownFields(true), binding.WithUnknownFieldContext("ClickHouse SQL spec")); err != nil {
-			return err
+		if err := UnmarshalJSONWithContext(shadow.Spec, &spec, "ClickHouse SQL spec"); err != nil {
+			return wrapUnmarshalError(err, "invalid ClickHouse SQL spec: %v", err)
 		}
 		q.Spec = spec
 
@@ -152,7 +151,7 @@ func (q *QueryEnvelope) UnmarshalJSON(data []byte) error {
 			shadow.Type,
 		).WithAdditional(
 			"Valid query types are: builder_query, builder_sub_query, builder_formula, builder_join, builder_trace_operator, promql, clickhouse_sql",
-		).WithSuggestions(errors.ValidReferences(QueryType{}.Enum()...))
+		)
 	}
 
 	return nil
@@ -176,27 +175,28 @@ func UnmarshalBuilderQueryBySignal(data []byte) (any, error) {
 	case telemetrytypes.SignalTraces:
 		var spec QueryBuilderQuery[TraceAggregation]
 		if err := json.Unmarshal(data, &spec); err != nil {
-			return nil, err
+			return nil, wrapUnmarshalError(err, "invalid trace builder query spec: %v", err)
 		}
 		return spec, nil
 	case telemetrytypes.SignalLogs:
 		var spec QueryBuilderQuery[LogAggregation]
 		if err := json.Unmarshal(data, &spec); err != nil {
-			return nil, err
+			return nil, wrapUnmarshalError(err, "invalid log builder query spec: %v", err)
 		}
 		return spec, nil
 	case telemetrytypes.SignalMetrics:
 		var spec QueryBuilderQuery[MetricAggregation]
 		if err := json.Unmarshal(data, &spec); err != nil {
-			return nil, err
+			return nil, wrapUnmarshalError(err, "invalid metric builder query spec: %v", err)
 		}
 		return spec, nil
 	default:
 		return nil, errors.NewInvalidInputf(
 			errors.CodeInvalidInput,
-			"invalid signal %q",
+			"invalid signal %q; allowed values: %v",
 			header.Signal.StringValue(),
-		).WithSuggestions(errors.ValidReferences(telemetrytypes.Signal{}.Enum()...))
+			telemetrytypes.Signal{}.Enum(),
+		)
 	}
 }
 
@@ -227,24 +227,36 @@ func (c *CompositeQuery) UnmarshalJSON(data []byte) error {
 		return err
 	}
 
-	// Valid field names are derived from the struct itself so this stays in
-	// sync with the schema (and the generated OpenAPI spec) automatically.
-	fieldNames := binding.JSONFieldNames((*CompositeQuery)(nil))
-	validFields := make(map[string]bool, len(fieldNames))
-	for _, f := range fieldNames {
-		validFields[f] = true
+	// Check for unknown fields at this level
+	validFields := map[string]bool{
+		"queries": true,
 	}
 
 	for field := range check {
 		if !validFields[field] {
-			unknownFieldErr := errors.NewInvalidInputf(
+			// Find closest match
+			var fieldNames []string
+			for f := range validFields {
+				fieldNames = append(fieldNames, f)
+			}
+
+			if suggestion, found := telemetrytypes.SuggestCorrection(field, fieldNames); found {
+				return errors.NewInvalidInputf(
+					errors.CodeInvalidInput,
+					"unknown field %q in composite query",
+					field,
+				).WithAdditional(
+					suggestion,
+				)
+			}
+
+			return errors.NewInvalidInputf(
 				errors.CodeInvalidInput,
 				"unknown field %q in composite query",
 				field,
 			).WithAdditional(
 				"Valid fields are: " + strings.Join(fieldNames, ", "),
-			).WithSuggestions(errors.SuggestionsOnLevenshteinDistance(field, fieldNames)...)
-			return unknownFieldErr
+			)
 		}
 	}
 
@@ -554,24 +566,43 @@ func (r *QueryRangeRequest) UnmarshalJSON(data []byte) error {
 		return err
 	}
 
-	// Valid field names are derived from the struct itself so this stays in
-	// sync with the schema (and the generated OpenAPI spec) automatically.
-	fieldNames := binding.JSONFieldNames((*QueryRangeRequest)(nil))
-	validFields := make(map[string]bool, len(fieldNames))
-	for _, f := range fieldNames {
-		validFields[f] = true
+	// Check for unknown fields at the top level
+	validFields := map[string]bool{
+		"schemaVersion":  true,
+		"start":          true,
+		"end":            true,
+		"requestType":    true,
+		"compositeQuery": true,
+		"variables":      true,
+		"noCache":        true,
+		"formatOptions":  true,
 	}
 
 	for field := range check {
 		if !validFields[field] {
-			unknownFieldErr := errors.NewInvalidInputf(
+			// Find closest match
+			var fieldNames []string
+			for f := range validFields {
+				fieldNames = append(fieldNames, f)
+			}
+
+			if suggestion, found := telemetrytypes.SuggestCorrection(field, fieldNames); found {
+				return errors.NewInvalidInputf(
+					errors.CodeInvalidInput,
+					"unknown field %q",
+					field,
+				).WithAdditional(
+					suggestion,
+				)
+			}
+
+			return errors.NewInvalidInputf(
 				errors.CodeInvalidInput,
 				"unknown field %q",
 				field,
 			).WithAdditional(
 				"Valid fields are: " + strings.Join(fieldNames, ", "),
-			).WithSuggestions(errors.SuggestionsOnLevenshteinDistance(field, fieldNames)...)
-			return unknownFieldErr
+			)
 		}
 	}
 

pkg/types/querybuildertypes/querybuildertypesv5/req_error_test.go

@@ -16,7 +16,6 @@ func TestQueryRangeRequest_UnmarshalJSON_ErrorMessages(t *testing.T) {
 		jsonData            string
 		wantErrMsg          string
 		wantAdditionalHints []string
-		wantSuggestions     []string
 	}{
 		{
 			name: "unknown field 'function' in query spec",
@@ -43,8 +42,10 @@ func TestQueryRangeRequest_UnmarshalJSON_ErrorMessages(t *testing.T) {
 					}]
 				}
 			}`,
-			wantErrMsg:      `unknown field "function" in query spec`,
-			wantSuggestions: []string{"did you mean: `functions`"},
+			wantErrMsg: `unknown field "function" in query spec`,
+			wantAdditionalHints: []string{
+				"did you mean: 'functions'?",
+			},
 		},
 		{
 			name: "unknown field 'filters' in query spec",
@@ -69,8 +70,10 @@ func TestQueryRangeRequest_UnmarshalJSON_ErrorMessages(t *testing.T) {
 					}]
 				}
 			}`,
-			wantErrMsg:      `unknown field "filters" in query spec`,
-			wantSuggestions: []string{"did you mean: `filter`"},
+			wantErrMsg: `unknown field "filters" in query spec`,
+			wantAdditionalHints: []string{
+				"did you mean: 'filter'?",
+			},
 		},
 		{
 			name: "unknown field at top level",
@@ -83,9 +86,10 @@ func TestQueryRangeRequest_UnmarshalJSON_ErrorMessages(t *testing.T) {
 					"queries": []
 				}
 			}`,
-			wantErrMsg:          `unknown field "compositeQueries"`,
-			wantAdditionalHints: []string{"Valid fields are:"},
-			wantSuggestions:     []string{"did you mean: `compositeQuery`"},
+			wantErrMsg: `unknown field "compositeQueries"`,
+			wantAdditionalHints: []string{
+				"did you mean: 'compositeQuery'?",
+			},
 		},
 		{
 			name: "unknown field with no good suggestion",
@@ -109,6 +113,9 @@ func TestQueryRangeRequest_UnmarshalJSON_ErrorMessages(t *testing.T) {
 				}
 			}`,
 			wantErrMsg: `unknown field "randomField" in query spec`,
+			wantAdditionalHints: []string{
+				"Valid fields are:",
+			},
 		},
 	}
 
@@ -122,28 +129,20 @@ func TestQueryRangeRequest_UnmarshalJSON_ErrorMessages(t *testing.T) {
 			// Check main error message
 			assert.Contains(t, err.Error(), tt.wantErrMsg)
 
-			// Inspect the structured error via its JSON representation.
-			j := errors.AsJSON(err)
+			// Check if it's an error from our package using Unwrapb
+			_, _, _, _, _, additionals := errors.Unwrapb(err)
 
-			// Check additional hints (the messages on the errors array) if we have any.
-			if len(j.Errors) > 0 {
+			// Check additional hints if we have any
+			if len(additionals) > 0 {
 				for _, hint := range tt.wantAdditionalHints {
 					found := false
-					for _, e := range j.Errors {
-						if strings.Contains(e.Message, hint) {
+					for _, additional := range additionals {
+						if strings.Contains(additional, hint) {
 							found = true
 							break
 						}
 					}
-					assert.True(t, found, "Expected to find hint '%s' in additionals: %v", hint, j.Errors)
-				}
-			}
-
-			// Typo suggestions are surfaced as structured (machine-consumable)
-			// suggestions, not in the human-facing additional hints.
-			if len(tt.wantSuggestions) > 0 {
-				for _, want := range tt.wantSuggestions {
-					assert.Contains(t, j.Suggestions, want, "Expected suggestion %q in %v", want, j.Suggestions)
+					assert.True(t, found, "Expected to find hint '%s' in additionals: %v", hint, additionals)
 				}
 			}
 		})

pkg/types/querybuildertypes/querybuildertypesv5/trace_operator.go

@@ -1,12 +1,10 @@
 package querybuildertypesv5
 
 import (
-	"bytes"
 	"regexp"
 	"strings"
 
 	"github.com/SigNoz/signoz/pkg/errors"
-	"github.com/SigNoz/signoz/pkg/http/binding"
 	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 	"github.com/SigNoz/signoz/pkg/valuer"
 )
@@ -374,8 +372,8 @@ func (q *QueryBuilderTraceOperator) UnmarshalJSON(data []byte) error {
 	type Alias QueryBuilderTraceOperator
 
 	var temp Alias
-	// Strict-decode the alias so unknown fields surface with field-name suggestions.
-	if err := binding.JSON.BindBody(bytes.NewReader(data), &temp, binding.WithDisallowUnknownFields(true), binding.WithUnknownFieldContext("query spec")); err != nil {
+	// Use UnmarshalJSONWithContext for better error messages
+	if err := UnmarshalJSONWithContext(data, &temp, "query spec"); err != nil {
 		return err
 	}
 

pkg/types/querybuildertypes/querybuildertypesv5/validation.go

@@ -38,30 +38,6 @@ func getQueryIdentifier(envelope QueryEnvelope, index int) string {
 	return fmt.Sprintf("%s at position %d", typeLabel, index+1)
 }
 
-// wrapValidationError rewraps a validation failure as errorFormat % (contextIdentifier,
-// innerMsg), carrying the inner error's additionals and suggestions onto the new error so
-// the structured hints survive the rewrap.
-func wrapValidationError(cause error, contextIdentifier string, errorFormat string) error {
-	if cause == nil {
-		return nil
-	}
-
-	_, _, innerMsg, _, _, additionals := errors.Unwrapb(cause)
-	inner := errors.AsJSON(cause)
-
-	newErr := errors.NewInvalidInputf(errors.CodeInvalidInput, errorFormat, contextIdentifier, innerMsg)
-
-	if len(additionals) > 0 {
-		newErr = newErr.WithAdditionals(additionals...)
-	}
-
-	if len(inner.Suggestions) > 0 {
-		newErr = newErr.WithSuggestions(inner.Suggestions...)
-	}
-
-	return newErr
-}
-
 const (
 	// Maximum limit for query results.
 	MaxQueryLimit = 10000
@@ -508,9 +484,6 @@ func (q *QueryBuilderQuery[T]) validateOrderByForAggregation() error {
 			}
 			slices.Sort(validKeys)
 
-			// Aggregation order-by keys are a small, exhaustive set (group-by keys,
-			// aggregation aliases/expressions, indices, __result), so a "valid references"
-			// list — unlike free-form field suggestions — is genuinely useful here.
 			return errors.NewInvalidInputf(
 				errors.CodeInvalidInput,
 				"invalid order by key '%s' for %s",
@@ -518,7 +491,7 @@ func (q *QueryBuilderQuery[T]) validateOrderByForAggregation() error {
 				orderId,
 			).WithAdditional(
 				fmt.Sprintf("For aggregation queries, order by can only reference group by keys, aggregation aliases/expressions, or aggregation indices. Valid keys are: %s", strings.Join(validKeys, ", ")),
-			).WithSuggestions(errors.SuggestionsOnLevenshteinDistance(orderKey, validKeys)...)
+			)
 		}
 	}
 
@@ -712,7 +685,7 @@ func validateQueryEnvelope(envelope QueryEnvelope, opts ...ValidationOption) err
 			envelope.Type,
 		).WithAdditional(
 			"Valid query types are: builder_query, builder_sub_query, builder_formula, builder_join, promql, clickhouse_sql, trace_operator",
-		).WithSuggestions(errors.ValidReferences(QueryType{}.Enum()...))
+		)
 	}
 }
 

pkg/types/telemetrytypes/maybe_typo.go

@@ -0,0 +1,111 @@
+package telemetrytypes
+
+import (
+	"fmt"
+	"strings"
+)
+
+const (
+	typoSuggestionThreshold = 0.75
+)
+
+// levenshteinDistance calculates the edit distance between two strings.
+func levenshteinDistance(s1, s2 string) int {
+	s1 = strings.ToLower(s1)
+	s2 = strings.ToLower(s2)
+
+	if len(s1) == 0 {
+		return len(s2)
+	}
+	if len(s2) == 0 {
+		return len(s1)
+	}
+
+	// Create two work vectors of integer distances
+	v0 := make([]int, len(s2)+1)
+	v1 := make([]int, len(s2)+1)
+
+	// Initialize v0 (the previous row of distances)
+	for i := 0; i <= len(s2); i++ {
+		v0[i] = i
+	}
+
+	// Calculate each row in the matrix
+	for i := range len(s1) {
+		v1[0] = i + 1
+
+		for j := range len(s2) {
+			deletionCost := v0[j+1] + 1
+			insertionCost := v1[j] + 1
+
+			var substitutionCost int
+			if s1[i] == s2[j] {
+				substitutionCost = v0[j]
+			} else {
+				substitutionCost = v0[j] + 1
+			}
+
+			v1[j+1] = min(deletionCost, insertionCost, substitutionCost)
+		}
+
+		// Copy v1 to v0 for next iteration
+		for j := 0; j <= len(s2); j++ {
+			v0[j] = v1[j]
+		}
+	}
+
+	return v1[len(s2)]
+}
+
+// similarity returns a value between 0 and 1, where 1 means perfect match.
+func similarity(s1, s2 string) float64 {
+	maxLen := max(len(s1), len(s2))
+	if maxLen == 0 {
+		return 1.0 // Both strings are empty
+	}
+
+	distance := levenshteinDistance(s1, s2)
+	return 1.0 - float64(distance)/float64(maxLen)
+}
+
+func min(a, b, c int) int {
+	if a < b {
+		if a < c {
+			return a
+		}
+		return c
+	}
+	if b < c {
+		return b
+	}
+	return c
+}
+
+func max(a, b int) int {
+	if a > b {
+		return a
+	}
+	return b
+}
+
+// SuggestCorrection checks if there are any column names similar to the input
+// and returns a suggestion if there's at least 75% similarity.
+func SuggestCorrection(input string, knownFieldKeys []string) (string, bool) {
+
+	var bestMatch string
+	bestSimilarity := 0.0
+
+	for _, columnName := range knownFieldKeys {
+		sim := similarity(input, columnName)
+		if sim > bestSimilarity && sim >= typoSuggestionThreshold {
+			bestSimilarity = sim
+			bestMatch = columnName
+		}
+	}
+
+	if bestSimilarity >= typoSuggestionThreshold {
+		return fmt.Sprintf("did you mean: '%s'?", bestMatch), true
+	}
+
+	return "", false
+}

tests/integration/testdata/inframonitoring/daemonsets_desired_current.jsonl

@@ -1,48 +0,0 @@
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"dc-p1-uid","k8s.pod.name":"dc-p1","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-1","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"dc-p2-uid","k8s.pod.name":"dc-p2","k8s.daemonset.name":"dc-ds","k8s.node.name":"node-2","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"dc-ds","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"dc-ds","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"dc-ds","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"dc-ds","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"dc-ds","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"dc-ds","k8s.namespace.name":"ns-dc","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/daemonsets_filter_dataset.jsonl

@@ -1,384 +0,0 @@
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p1-uid", "k8s.pod.name": "logs-a-prod-acc-1-p1", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-prod-acc-1-p2-uid", "k8s.pod.name": "logs-a-prod-acc-1-p2", "k8s.daemonset.name": "logs-a-prod", "k8s.node.name": "logs-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p1-uid", "k8s.pod.name": "logs-a-dev-acc-1-p1", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-a-dev-acc-1-p2-uid", "k8s.pod.name": "logs-a-dev-acc-1-p2", "k8s.daemonset.name": "logs-a-dev", "k8s.node.name": "logs-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p1", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-a-prod-acc-1-p2", "k8s.daemonset.name": "metrics-a-prod", "k8s.node.name": "metrics-a-prod-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-prod", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p1", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-a", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-a-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-a-dev-acc-1-p2", "k8s.daemonset.name": "metrics-a-dev", "k8s.node.name": "metrics-a-dev-node-b", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-a-dev", "k8s.namespace.name": "ns-a", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p1-uid", "k8s.pod.name": "logs-b-prod-acc-1-p1", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-prod-acc-1-p2-uid", "k8s.pod.name": "logs-b-prod-acc-1-p2", "k8s.daemonset.name": "logs-b-prod", "k8s.node.name": "logs-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p1-uid", "k8s.pod.name": "logs-b-dev-acc-1-p1", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "logs-b-dev-acc-1-p2-uid", "k8s.pod.name": "logs-b-dev-acc-1-p2", "k8s.daemonset.name": "logs-b-dev", "k8s.node.name": "logs-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "logs-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p1-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p1", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-prod-acc-1-p2-uid", "k8s.pod.name": "metrics-b-prod-acc-1-p2", "k8s.daemonset.name": "metrics-b-prod", "k8s.node.name": "metrics-b-prod-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-prod", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.4, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p1-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p1", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-a", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 200000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "metrics-b-dev-acc-1-p2-uid", "k8s.pod.name": "metrics-b-dev-acc-1-p2", "k8s.daemonset.name": "metrics-b-dev", "k8s.node.name": "metrics-b-dev-node-b", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.desired_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 3, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
-{"metric_name": "k8s.daemonset.current_scheduled_nodes", "labels": {"k8s.daemonset.name": "metrics-b-dev", "k8s.namespace.name": "ns-b", "k8s.cluster.name": "cluster-x", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}

tests/integration/testdata/inframonitoring/daemonsets_groupby.jsonl

@@ -1,108 +0,0 @@
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-a1-p1-uid","k8s.pod.name":"gb-ds-a1-p1","k8s.daemonset.name":"gb-ds-a1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a1","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a1","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a1","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a1","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a1","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a1","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-a2-p1-uid","k8s.pod.name":"gb-ds-a2-p1","k8s.daemonset.name":"gb-ds-a2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a2","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a2","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a2","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a2","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a2","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-a2","k8s.namespace.name":"gb-ns-a","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-b1-p1-uid","k8s.pod.name":"gb-ds-b1-p1","k8s.daemonset.name":"gb-ds-b1","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b1","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b1","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b1","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b1","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b1","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b1","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"gb-ds-b2-p1-uid","k8s.pod.name":"gb-ds-b2-p1","k8s.daemonset.name":"gb-ds-b2","k8s.node.name":"node-x","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b2","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b2","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b2","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b2","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b2","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"gb-ds-b2","k8s.namespace.name":"gb-ns-b","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/daemonsets_missing_metrics.jsonl

@@ -1,3 +0,0 @@
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"miss-p1-uid","k8s.pod.name":"miss-p1","k8s.daemonset.name":"miss-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-miss","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"miss-p1-uid","k8s.pod.name":"miss-p1","k8s.daemonset.name":"miss-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-miss","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"miss-p1-uid","k8s.pod.name":"miss-p1","k8s.daemonset.name":"miss-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-miss","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/daemonsets_non_ds_pods.jsonl

@@ -1,90 +0,0 @@
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-ds-p1-uid","k8s.pod.name":"nd-ds-p1","k8s.daemonset.name":"nd-ds","k8s.node.name":"node-x","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"nd-ds","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"nd-ds","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"nd-ds","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"nd-ds","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.desired_scheduled_nodes","labels":{"k8s.daemonset.name":"nd-ds","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.daemonset.current_scheduled_nodes","labels":{"k8s.daemonset.name":"nd-ds","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-standalone-uid","k8s.pod.name":"nd-standalone","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-dep-uid","k8s.pod.name":"nd-dep-pod","k8s.deployment.name":"nd-dep","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
-{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"nd-ss-uid","k8s.pod.name":"nd-ss-pod","k8s.statefulset.name":"nd-ss","k8s.namespace.name":"ns-nd","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}