chore(release): bump to v0.128.0 (#11633)

Co-authored-by: primus-bot[bot] <171087277+primus-bot[bot]@users.noreply.github.com>

.github/workflows/build-staging.yaml

@@ -64,6 +64,10 @@ jobs:
         run: |
           mkdir -p frontend
           echo 'CI=1' > frontend/.env
+          echo 'VITE_SENTRY_AUTH_TOKEN="${{ secrets.SENTRY_AUTH_TOKEN }}"' >> frontend/.env
+          echo 'VITE_SENTRY_ORG="${{ secrets.SENTRY_ORG }}"' >> frontend/.env
+          echo 'VITE_SENTRY_PROJECT_ID="${{ secrets.SENTRY_PROJECT_ID }}"' >> frontend/.env
+          echo 'VITE_SENTRY_DSN="${{ secrets.SENTRY_DSN }}"' >> frontend/.env
           echo 'VITE_TUNNEL_URL="${{ secrets.NP_TUNNEL_URL }}"' >> frontend/.env
           echo 'VITE_TUNNEL_DOMAIN="${{ secrets.NP_TUNNEL_DOMAIN }}"' >> frontend/.env
           echo 'VITE_PYLON_APP_ID="${{ secrets.NP_PYLON_APP_ID }}"' >> frontend/.env

deploy/docker-swarm/docker-compose.ha.yaml

@@ -190,7 +190,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.127.1
+    image: signoz/signoz:v0.128.0
     ports:
       - "8080:8080" # signoz port
     #   - "6060:6060"     # pprof port

deploy/docker-swarm/docker-compose.yaml

@@ -117,7 +117,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:v0.127.1
+    image: signoz/signoz:v0.128.0
     ports:
       - "8080:8080" # signoz port
     volumes:

deploy/docker/docker-compose.ha.yaml

@@ -181,7 +181,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.127.1}
+    image: signoz/signoz:${VERSION:-v0.128.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

deploy/docker/docker-compose.yaml

@@ -109,7 +109,7 @@ services:
       # - ../common/clickhouse/storage.xml:/etc/clickhouse-server/config.d/storage.xml
   signoz:
     !!merge <<: *db-depend
-    image: signoz/signoz:${VERSION:-v0.127.1}
+    image: signoz/signoz:${VERSION:-v0.128.0}
     container_name: signoz
     ports:
       - "8080:8080" # signoz port

docs/api/openapi.yml

@@ -1360,6 +1360,8 @@ components:
       - sqs
       - storageaccountsblob
       - cdnprofile
+      - virtualmachine
+      - appservice
       - containerapp
       - aks
       type: string
@@ -6724,11 +6726,6 @@ components:
       type: object
     SpantypesGettableWaterfallTrace:
       properties:
-        aggregations:
-          items:
-            $ref: '#/components/schemas/SpantypesSpanAggregationResult'
-          nullable: true
-          type: array
         endTimestampMillis:
           minimum: 0
           type: integer
@@ -6816,14 +6813,6 @@ components:
       type: object
     SpantypesPostableWaterfall:
       properties:
-        aggregations:
-          items:
-            $ref: '#/components/schemas/SpantypesSpanAggregation'
-          nullable: true
-          type: array
-        limit:
-          minimum: 0
-          type: integer
         selectedSpanId:
           type: string
         uncollapsedSpans:
@@ -20679,76 +20668,6 @@ paths:
       summary: Get flamegraph view for a trace
       tags:
       - tracedetail
-  /api/v3/traces/{traceID}/waterfall:
-    post:
-      deprecated: false
-      description: Returns the waterfall view of spans for a given trace ID with tree
-        structure, metadata, and windowed pagination
-      operationId: GetWaterfall
-      parameters:
-      - in: path
-        name: traceID
-        required: true
-        schema:
-          type: string
-      requestBody:
-        content:
-          application/json:
-            schema:
-              $ref: '#/components/schemas/SpantypesPostableWaterfall'
-      responses:
-        "200":
-          content:
-            application/json:
-              schema:
-                properties:
-                  data:
-                    $ref: '#/components/schemas/SpantypesGettableWaterfallTrace'
-                  status:
-                    type: string
-                required:
-                - status
-                - data
-                type: object
-          description: OK
-        "400":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Bad Request
-        "401":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Unauthorized
-        "403":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Forbidden
-        "404":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Not Found
-        "500":
-          content:
-            application/json:
-              schema:
-                $ref: '#/components/schemas/RenderErrorResponse'
-          description: Internal Server Error
-      security:
-      - api_key:
-        - VIEWER
-      - tokenizer:
-        - VIEWER
-      summary: Get waterfall view for a trace
-      tags:
-      - tracedetail
   /api/v4/traces/{traceID}/waterfall:
     post:
       deprecated: false

frontend/src/api/alerts/getTriggered.ts

@@ -5,6 +5,13 @@ import convertObjectIntoParams from 'lib/query/convertObjectIntoParams';
 import { ErrorResponse, SuccessResponse } from 'types/api';
 import { PayloadProps, Props } from 'types/api/alerts/getTriggered';
 
+/**
+ * @deprecated Use the generated `useGetAlerts` hook (or `getAlerts` fetcher) from
+ * `api/generated/services/alerts` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const getTriggered = async (
 	props: Props,
 ): Promise<SuccessResponse<PayloadProps> | ErrorResponse> => {

frontend/src/api/channels/createEmail.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createEmail';
 
+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/createMsTeams.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createMsTeams';
 
+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/createOpsgenie.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createOpsgenie';
 
+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/createPager.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createPager';
 
+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/createSlack.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createSlack';
 
+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/createWebhook.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/createWebhook';
 
+/**
+ * @deprecated Use the generated `useCreateChannel` hook (or `createChannel` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const create = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/delete.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/delete';
 
+/**
+ * @deprecated Use the generated `useDeleteChannelByID` hook (or `deleteChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const deleteChannel = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/editEmail.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editEmail';
 
+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editEmail = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/editMsTeams.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editMsTeams';
 
+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editMsTeams = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/editOpsgenie.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorResponse, ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editOpsgenie';
 
+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editOpsgenie = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps> | ErrorResponse> => {

frontend/src/api/channels/editPager.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editPager';
 
+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editPager = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/editSlack.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editSlack';
 
+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editSlack = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/editWebhook.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/editWebhook';
 
+/**
+ * @deprecated Use the generated `useUpdateChannelByID` hook (or `updateChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const editWebhook = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/channels/get.ts

@@ -5,6 +5,13 @@ import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/channels/get';
 import { Channels } from 'types/api/channels/getAll';
 
+/**
+ * @deprecated Use the generated `useGetChannelByID` hook (or `getChannelByID` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const get = async (props: Props): Promise<SuccessResponseV2<Channels>> => {
 	try {
 		const response = await axios.get<PayloadProps>(`/channels/${props.id}`);

frontend/src/api/channels/getAll.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { Channels, PayloadProps } from 'types/api/channels/getAll';
 
+/**
+ * @deprecated Use the generated `useListChannels` hook (or `listChannels` fetcher) from
+ * `api/generated/services/channels` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const getAll = async (): Promise<SuccessResponseV2<Channels[]>> => {
 	try {
 		const response = await axios.get<PayloadProps>('/channels');

frontend/src/api/dashboard/public/createPublicDashboard.ts

@@ -5,6 +5,13 @@ import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constan
 import { ErrorV2Resp, 	 SuccessResponseV2 } from 'types/api';
 import { CreatePublicDashboardProps } from 'types/api/dashboard/public/create';
 
+/**
+ * @deprecated Use the generated `useCreatePublicDashboard` hook (or `createPublicDashboard` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const createPublicDashboard = async (
 	props: CreatePublicDashboardProps,
 ): Promise<SuccessResponseV2<CreatePublicDashboardProps>> => {

frontend/src/api/dashboard/public/getPublicDashboardData.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { GetPublicDashboardDataProps, PayloadProps,PublicDashboardDataProps } from 'types/api/dashboard/public/get';
 
+/**
+ * @deprecated Use the generated `useGetPublicDashboardData` hook (or `getPublicDashboardData` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const getPublicDashboardData = async (props: GetPublicDashboardDataProps): Promise<SuccessResponseV2<PublicDashboardDataProps>> => {
 	try {
 		const response = await axios.get<PayloadProps>(`/public/dashboards/${props.id}`);

frontend/src/api/dashboard/public/getPublicDashboardMeta.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { GetPublicDashboardMetaProps, PayloadProps,PublicDashboardMetaProps } from 'types/api/dashboard/public/getMeta';
 
+/**
+ * @deprecated Use the generated `useGetPublicDashboard` hook (or `getPublicDashboard` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const getPublicDashboardMeta = async (props: GetPublicDashboardMetaProps): Promise<SuccessResponseV2<PublicDashboardMetaProps>> => {
 	try {
 		const response = await axios.get<PayloadProps>(`/dashboards/${props.id}/public`);

frontend/src/api/dashboard/public/getPublicDashboardWidgetData.ts

@@ -6,6 +6,13 @@ import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { GetPublicDashboardWidgetDataProps } from 'types/api/dashboard/public/getWidgetData';
 
 
+/**
+ * @deprecated Use the generated `useGetPublicDashboardWidgetQueryRange` hook (or `getPublicDashboardWidgetQueryRange` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const getPublicDashboardWidgetData = async (props: GetPublicDashboardWidgetDataProps): Promise<SuccessResponseV2<MetricRangePayloadV5>> => {
 	try {
 		const response = await axios.get(`/public/dashboards/${props.id}/widgets/${props.index}/query_range`, {

frontend/src/api/dashboard/public/revokePublicDashboardAccess.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps,RevokePublicDashboardAccessProps } from 'types/api/dashboard/public/delete';
 
+/**
+ * @deprecated Use the generated `useDeletePublicDashboard` hook (or `deletePublicDashboard` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const revokePublicDashboardAccess = async (
 	props: RevokePublicDashboardAccessProps,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/dashboard/public/updatePublicDashboard.ts

@@ -5,6 +5,13 @@ import { DEFAULT_TIME_RANGE } from 'container/TopNav/DateTimeSelectionV2/constan
 import {  ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { UpdatePublicDashboardProps } from 'types/api/dashboard/public/update';
 
+/**
+ * @deprecated Use the generated `useUpdatePublicDashboard` hook (or `updatePublicDashboard` fetcher) from
+ * `api/generated/services/dashboard` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const updatePublicDashboard = async (
 	props: UpdatePublicDashboardProps,
 ): Promise<SuccessResponseV2<UpdatePublicDashboardProps>> => {

frontend/src/api/dashboard/substitute_vars.ts

@@ -9,6 +9,13 @@ interface ISubstituteVars {
 	compositeQuery: ICompositeMetricQuery;
 }
 
+/**
+ * @deprecated Use the generated `useReplaceVariables` hook (or `replaceVariables` fetcher) from
+ * `api/generated/services/querier` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 export const getSubstituteVars = async (
 	props?: Partial<QueryRangePayloadV5>,
 	signal?: AbortSignal,

frontend/src/api/dynamicVariables/getFieldKeys.ts

@@ -8,6 +8,12 @@ import { FieldKeyResponse } from 'types/api/dynamicVariables/getFieldKeys';
  * Get field keys for a given signal type
  * @param signal Type of signal (traces, logs, metrics)
  * @param name Optional search text
+ *
+ * @deprecated Use the generated `useGetFieldsKeys` hook (or `getFieldsKeys` fetcher) from
+ * `api/generated/services/fields` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
  */
 export const getFieldKeys = async (
 	signal?: 'traces' | 'logs' | 'metrics',

frontend/src/api/dynamicVariables/getFieldValues.ts

@@ -11,6 +11,12 @@ import { FieldValueResponse } from 'types/api/dynamicVariables/getFieldValues';
  * @param name Name of the attribute for which values are being fetched
  * @param value Optional search text
  * @param existingQuery Optional existing query - across all present dynamic variables
+ *
+ * @deprecated Use the generated `useGetFieldsValues` hook (or `getFieldsValues` fetcher) from
+ * `api/generated/services/fields` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
  */
 export const getFieldValues = async (
 	signal?: 'traces' | 'logs' | 'metrics',

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

@@ -2651,6 +2651,8 @@ export enum CloudintegrationtypesServiceIDDTO {
 	sqs = 'sqs',
 	storageaccountsblob = 'storageaccountsblob',
 	cdnprofile = 'cdnprofile',
+	virtualmachine = 'virtualmachine',
+	appservice = 'appservice',
 	containerapp = 'containerapp',
 	aks = 'aks',
 }
@@ -8093,10 +8095,6 @@ export interface SpantypesWaterfallSpanDTO {
 }
 
 export interface SpantypesGettableWaterfallTraceDTO {
-	/**
-	 * @type array,null
-	 */
-	aggregations?: SpantypesSpanAggregationResultDTO[] | null;
 	/**
 	 * @type integer
 	 * @minimum 0
@@ -8216,15 +8214,6 @@ export interface SpantypesPostableTraceAggregationsDTO {
 }
 
 export interface SpantypesPostableWaterfallDTO {
-	/**
-	 * @type array,null
-	 */
-	aggregations?: SpantypesSpanAggregationDTO[] | null;
-	/**
-	 * @type integer
-	 * @minimum 0
-	 */
-	limit?: number;
 	/**
 	 * @type string
 	 */
@@ -10519,17 +10508,6 @@ export type GetFlamegraph200 = {
 	status: string;
 };
 
-export type GetWaterfallPathParameters = {
-	traceID: string;
-};
-export type GetWaterfall200 = {
-	data: SpantypesGettableWaterfallTraceDTO;
-	/**
-	 * @type string
-	 */
-	status: string;
-};
-
 export type GetWaterfallV4PathParameters = {
 	traceID: string;
 };

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

@@ -16,8 +16,6 @@ import type {
 	GetFlamegraphPathParameters,
 	GetTraceAggregations200,
 	GetTraceAggregationsPathParameters,
-	GetWaterfall200,
-	GetWaterfallPathParameters,
 	GetWaterfallV4200,
 	GetWaterfallV4PathParameters,
 	RenderErrorResponseDTO,
@@ -228,105 +226,6 @@ export const useGetFlamegraph = <
 > => {
 	return useMutation(getGetFlamegraphMutationOptions(options));
 };
-/**
- * Returns the waterfall view of spans for a given trace ID with tree structure, metadata, and windowed pagination
- * @summary Get waterfall view for a trace
- */
-export const getWaterfall = (
-	{ traceID }: GetWaterfallPathParameters,
-	spantypesPostableWaterfallDTO?: BodyType<SpantypesPostableWaterfallDTO>,
-	signal?: AbortSignal,
-) => {
-	return GeneratedAPIInstance<GetWaterfall200>({
-		url: `/api/v3/traces/${traceID}/waterfall`,
-		method: 'POST',
-		headers: { 'Content-Type': 'application/json' },
-		data: spantypesPostableWaterfallDTO,
-		signal,
-	});
-};
-
-export const getGetWaterfallMutationOptions = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof getWaterfall>>,
-		TError,
-		{
-			pathParams: GetWaterfallPathParameters;
-			data?: BodyType<SpantypesPostableWaterfallDTO>;
-		},
-		TContext
-	>;
-}): UseMutationOptions<
-	Awaited<ReturnType<typeof getWaterfall>>,
-	TError,
-	{
-		pathParams: GetWaterfallPathParameters;
-		data?: BodyType<SpantypesPostableWaterfallDTO>;
-	},
-	TContext
-> => {
-	const mutationKey = ['getWaterfall'];
-	const { mutation: mutationOptions } = options
-		? options.mutation &&
-			'mutationKey' in options.mutation &&
-			options.mutation.mutationKey
-			? options
-			: { ...options, mutation: { ...options.mutation, mutationKey } }
-		: { mutation: { mutationKey } };
-
-	const mutationFn: MutationFunction<
-		Awaited<ReturnType<typeof getWaterfall>>,
-		{
-			pathParams: GetWaterfallPathParameters;
-			data?: BodyType<SpantypesPostableWaterfallDTO>;
-		}
-	> = (props) => {
-		const { pathParams, data } = props ?? {};
-
-		return getWaterfall(pathParams, data);
-	};
-
-	return { mutationFn, ...mutationOptions };
-};
-
-export type GetWaterfallMutationResult = NonNullable<
-	Awaited<ReturnType<typeof getWaterfall>>
->;
-export type GetWaterfallMutationBody =
-	| BodyType<SpantypesPostableWaterfallDTO>
-	| undefined;
-export type GetWaterfallMutationError = ErrorType<RenderErrorResponseDTO>;
-
-/**
- * @summary Get waterfall view for a trace
- */
-export const useGetWaterfall = <
-	TError = ErrorType<RenderErrorResponseDTO>,
-	TContext = unknown,
->(options?: {
-	mutation?: UseMutationOptions<
-		Awaited<ReturnType<typeof getWaterfall>>,
-		TError,
-		{
-			pathParams: GetWaterfallPathParameters;
-			data?: BodyType<SpantypesPostableWaterfallDTO>;
-		},
-		TContext
-	>;
-}): UseMutationResult<
-	Awaited<ReturnType<typeof getWaterfall>>,
-	TError,
-	{
-		pathParams: GetWaterfallPathParameters;
-		data?: BodyType<SpantypesPostableWaterfallDTO>;
-	},
-	TContext
-> => {
-	return useMutation(getGetWaterfallMutationOptions(options));
-};
 /**
  * Returns the waterfall view of spans including all spans if total spans are under a limit, a max count otherwise. Aggregations are dropped compared to v3
  * @summary Get waterfall view for a trace

frontend/src/api/querySuggestions/getKeySuggestions.ts

@@ -5,6 +5,13 @@ import {
 	QueryKeySuggestionsResponseProps,
 } from 'types/api/querySuggestions/types';
 
+/**
+ * @deprecated Use the generated `useGetFieldsKeys` hook (or `getFieldsKeys` fetcher) from
+ * `api/generated/services/fields` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 export const getKeySuggestions = (
 	props: QueryKeyRequestProps,
 ): Promise<AxiosResponse<QueryKeySuggestionsResponseProps>> => {

frontend/src/api/querySuggestions/getValueSuggestion.ts

@@ -5,6 +5,13 @@ import {
 	QueryKeyValueSuggestionsResponseProps,
 } from 'types/api/querySuggestions/types';
 
+/**
+ * @deprecated Use the generated `useGetFieldsValues` hook (or `getFieldsValues` fetcher) from
+ * `api/generated/services/fields` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 export const getValueSuggestions = (
 	props: QueryKeyValueRequestProps,
 ): Promise<AxiosResponse<QueryKeyValueSuggestionsResponseProps>> => {

frontend/src/api/routingPolicies/createRoutingPolicy.ts

@@ -15,6 +15,13 @@ export interface CreateRoutingPolicyResponse {
 	message: string;
 }
 
+/**
+ * @deprecated Use the generated `useCreateRoutePolicy` hook (or `createRoutePolicy` fetcher) from
+ * `api/generated/services/routepolicies` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const createRoutingPolicy = async (
 	props: CreateRoutingPolicyBody,
 ): Promise<

frontend/src/api/routingPolicies/deleteRoutingPolicy.ts

@@ -8,6 +8,13 @@ export interface DeleteRoutingPolicyResponse {
 	message: string;
 }
 
+/**
+ * @deprecated Use the generated `useDeleteRoutePolicyByID` hook (or `deleteRoutePolicyByID` fetcher) from
+ * `api/generated/services/routepolicies` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const deleteRoutingPolicy = async (
 	routingPolicyId: string,
 ): Promise<

frontend/src/api/routingPolicies/getRoutingPolicies.ts

@@ -20,6 +20,13 @@ export interface GetRoutingPoliciesResponse {
 	data?: ApiRoutingPolicy[];
 }
 
+/**
+ * @deprecated Use the generated `useGetAllRoutePolicies` hook (or `getAllRoutePolicies` fetcher) from
+ * `api/generated/services/routepolicies` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 export const getRoutingPolicies = async (
 	signal?: AbortSignal,
 	headers?: Record<string, string>,

frontend/src/api/routingPolicies/updateRoutingPolicy.ts

@@ -15,6 +15,13 @@ export interface UpdateRoutingPolicyResponse {
 	message: string;
 }
 
+/**
+ * @deprecated Use the generated `useUpdateRoutePolicy` hook (or `updateRoutePolicy` fetcher) from
+ * `api/generated/services/routepolicies` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const updateRoutingPolicy = async (
 	id: string,
 	props: UpdateRoutingPolicyBody,

frontend/src/api/trace/getTraceV4.tsx

@@ -27,7 +27,6 @@ const getTraceV4 = async (
 		{
 			selectedSpanId: props.selectedSpanId,
 			uncollapsedSpans,
-			limit: 10000,
 		},
 	);
 

frontend/src/api/v1/factor_password/resetPassword.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/user/resetPassword';
 
+/**
+ * @deprecated Use the generated `useResetPassword` hook (or `resetPassword` fetcher) from
+ * `api/generated/services/users` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const resetPassword = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/v1/invite/bulk/create.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { UsersProps } from 'types/api/user/inviteUsers';
 
+/**
+ * @deprecated Use the generated `useCreateBulkInvite` hook (or `createBulkInvite` fetcher) from
+ * `api/generated/services/users` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const inviteUsers = async (
 	users: UsersProps,
 ): Promise<SuccessResponseV2<null>> => {

frontend/src/api/v1/invite/create.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/user/setInvite';
 
+/**
+ * @deprecated Use the generated `useCreateInvite` hook (or `createInvite` fetcher) from
+ * `api/generated/services/users` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const sendInvite = async (
 	props: Props,
 ): Promise<SuccessResponseV2<PayloadProps>> => {

frontend/src/api/v1/org/preferences/list.ts

@@ -5,6 +5,13 @@ import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps } from 'types/api/preferences/list';
 import { OrgPreference } from 'types/api/preferences/preference';
 
+/**
+ * @deprecated Use the generated `useListOrgPreferences` hook (or `listOrgPreferences` fetcher) from
+ * `api/generated/services/preferences` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const listPreference = async (): Promise<
 	SuccessResponseV2<OrgPreference[]>
 > => {

frontend/src/api/v1/org/preferences/name/update.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { Props } from 'types/api/preferences/update';
 
+/**
+ * @deprecated Use the generated `useUpdateOrgPreference` hook (or `updateOrgPreference` fetcher) from
+ * `api/generated/services/preferences` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const update = async (props: Props): Promise<SuccessResponseV2<null>> => {
 	try {
 		const response = await axios.put(`/org/preferences/${props.name}`, {

frontend/src/api/v1/user/preferences/list.ts

@@ -5,6 +5,13 @@ import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps } from 'types/api/preferences/list';
 import { UserPreference } from 'types/api/preferences/preference';
 
+/**
+ * @deprecated Use the generated `useListUserPreferences` hook (or `listUserPreferences` fetcher) from
+ * `api/generated/services/preferences` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const list = async (): Promise<SuccessResponseV2<UserPreference[]>> => {
 	try {
 		const response = await axios.get<PayloadProps>(`/user/preferences`);

frontend/src/api/v1/user/preferences/name/get.ts

@@ -5,6 +5,13 @@ import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { PayloadProps, Props } from 'types/api/preferences/get';
 import { UserPreference } from 'types/api/preferences/preference';
 
+/**
+ * @deprecated Use the generated `useGetUserPreference` hook (or `getUserPreference` fetcher) from
+ * `api/generated/services/preferences` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const get = async (
 	props: Props,
 ): Promise<SuccessResponseV2<UserPreference>> => {

frontend/src/api/v1/user/preferences/name/update.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, SuccessResponseV2 } from 'types/api';
 import { Props } from 'types/api/preferences/update';
 
+/**
+ * @deprecated Use the generated `useUpdateUserPreference` hook (or `updateUserPreference` fetcher) from
+ * `api/generated/services/preferences` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const update = async (props: Props): Promise<SuccessResponseV2<null>> => {
 	try {
 		const response = await axios.put(`/user/preferences/${props.name}`, {

frontend/src/api/v2/sessions/context/get.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
 import { Props, SessionsContext } from 'types/api/v2/sessions/context/get';
 
+/**
+ * @deprecated Use the generated `useGetSessionContext` hook (or `getSessionContext` fetcher) from
+ * `api/generated/services/sessions` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const get = async (
 	props: Props,
 ): Promise<SuccessResponseV2<SessionsContext>> => {

frontend/src/api/v2/sessions/delete.ts

@@ -3,6 +3,13 @@ import { ErrorResponseHandlerV2 } from 'api/ErrorResponseHandlerV2';
 import { AxiosError } from 'axios';
 import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
 
+/**
+ * @deprecated Use the generated `useDeleteSession` hook (or `deleteSession` fetcher) from
+ * `api/generated/services/sessions` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const deleteSession = async (): Promise<SuccessResponseV2<null>> => {
 	try {
 		const response = await axios.delete<RawSuccessResponse<null>>('/sessions');

frontend/src/api/v2/sessions/email_password/post.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
 import { Props, Token } from 'types/api/v2/sessions/email_password/post';
 
+/**
+ * @deprecated Use the generated `useCreateSessionByEmailPassword` hook (or `createSessionByEmailPassword` fetcher) from
+ * `api/generated/services/sessions` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const post = async (props: Props): Promise<SuccessResponseV2<Token>> => {
 	try {
 		const response = await axios.post<RawSuccessResponse<Token>>(

frontend/src/api/v2/sessions/rotate/post.ts

@@ -4,6 +4,13 @@ import { AxiosError } from 'axios';
 import { ErrorV2Resp, RawSuccessResponse, SuccessResponseV2 } from 'types/api';
 import { Props, Token } from 'types/api/v2/sessions/rotate/post';
 
+/**
+ * @deprecated Use the generated `useRotateSession` hook (or `rotateSession` fetcher) from
+ * `api/generated/services/sessions` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 const post = async (props: Props): Promise<SuccessResponseV2<Token>> => {
 	try {
 		const response = await axios.post<RawSuccessResponse<Token>>(

frontend/src/api/v5/queryRange/getQueryRange.ts

@@ -8,6 +8,13 @@ import {
 	QueryRangePayloadV5,
 } from 'types/api/v5/queryRange';
 
+/**
+ * @deprecated Use the generated `useQueryRangeV5` hook (or `queryRangeV5` fetcher) from
+ * `api/generated/services/querier` instead. This hand-written client targets the
+ * same endpoint and will be removed once call sites migrate.
+ *
+ * Part of https://github.com/SigNoz/engineering-pod/issues/5289, add a comment or update when removing this method.
+ */
 export const getQueryRangeV5 = async (
 	props: QueryRangePayloadV5,
 	version: string,

frontend/src/container/AIAssistant/events.ts

@@ -70,6 +70,7 @@ export const AIAssistantOpenSource = {
 	Icon: 'icon',
 	Shortcut: 'shortcut',
 	Cmdk: 'cmdk',
+	TraceDetails: 'trace_details',
 } as const;
 export type AIAssistantOpenSource =
 	(typeof AIAssistantOpenSource)[keyof typeof AIAssistantOpenSource];

frontend/src/container/BillingContainer/CancelSubscriptionBanner.module.scss

@@ -67,3 +67,40 @@
 	background: var(--secondary-background);
 	border: 1px solid var(--l1-border);
 }
+
+.fallbackBody {
+	display: flex;
+	flex-direction: column;
+	gap: var(--spacing-4);
+}
+
+.fallbackHint {
+	font-size: var(--paragraph-base-400-font-size);
+	font-weight: var(--paragraph-base-400-font-weight);
+	line-height: var(--paragraph-base-400-line-height);
+	color: var(--l2-foreground);
+	margin: 0;
+}
+
+.fallbackEmail {
+	font-size: var(--paragraph-base-500-font-size);
+	font-weight: var(--paragraph-base-500-font-weight);
+	color: var(--l1-foreground);
+	word-break: break-all;
+}
+
+.fallbackActions {
+	display: flex;
+	gap: var(--spacing-3);
+	flex-wrap: wrap;
+	padding-top: var(--padding-4);
+}
+
+.retryLink {
+	box-sizing: border-box;
+	text-decoration: none;
+
+	&:hover {
+		text-decoration: none;
+	}
+}

frontend/src/container/BillingContainer/CancelSubscriptionBanner.test.tsx

@@ -9,7 +9,37 @@ jest.mock('utils/basePath', () => ({
 	getBaseUrl: (): string => 'https://test.signoz.io',
 }));
 
+function mockMailto(): {
+	mockClick: jest.Mock;
+	appendSpy: jest.SpyInstance;
+	removeSpy: jest.SpyInstance;
+} {
+	const mockClick = jest.fn();
+	const realCreateElement = document.createElement.bind(document);
+
+	// Create a real anchor so JSDOM's appendChild/removeChild accept it.
+	// Override its click() so no navigation occurs.
+	jest
+		.spyOn(document, 'createElement')
+		.mockImplementation((tag: string, options?: ElementCreationOptions) => {
+			if (tag === 'a') {
+				const anchor = realCreateElement('a') as HTMLAnchorElement;
+				anchor.click = mockClick;
+				return anchor;
+			}
+			return realCreateElement(tag, options);
+		});
+
+	const appendSpy = jest.spyOn(document.body, 'appendChild');
+	const removeSpy = jest.spyOn(document.body, 'removeChild');
+	return { mockClick, appendSpy, removeSpy };
+}
+
 describe('CancelSubscriptionBanner', () => {
+	afterEach(() => {
+		jest.restoreAllMocks();
+	});
+
 	it('renders banner with title and subtitle', () => {
 		render(<CancelSubscriptionBanner />);
 		expect(
@@ -35,12 +65,10 @@ describe('CancelSubscriptionBanner', () => {
 			screen.getByText(/Cancelling your subscription would stop your data/i),
 		).toBeInTheDocument();
 		expect(screen.getByText(/Type/i)).toBeInTheDocument();
-		expect(
-			screen.getByPlaceholderText(/Enter the word cancel/i),
-		).toBeInTheDocument();
+		expect(screen.getByTestId('cancel-confirm-input')).toBeInTheDocument();
 		expect(screen.getByRole('button', { name: /go back/i })).toBeInTheDocument();
 		expect(
-			screen.getByRole('button', { name: /cancel subscription/i }),
+			screen.getByTestId('cancel-subscription-confirm-btn'),
 		).toBeInTheDocument();
 	});
 
@@ -52,12 +80,10 @@ describe('CancelSubscriptionBanner', () => {
 			screen.getByRole('button', { name: /cancel subscription/i }),
 		);
 
-		const confirmButton = screen.getByRole('button', {
-			name: /cancel subscription/i,
-		});
+		const confirmButton = screen.getByTestId('cancel-subscription-confirm-btn');
 		expect(confirmButton).toBeDisabled();
 
-		const input = screen.getByPlaceholderText(/Enter the word cancel/i);
+		const input = screen.getByTestId('cancel-confirm-input');
 		await user.type(input, 'canc');
 		expect(confirmButton).toBeDisabled();
 
@@ -73,7 +99,7 @@ describe('CancelSubscriptionBanner', () => {
 			screen.getByRole('button', { name: /cancel subscription/i }),
 		);
 
-		const input = screen.getByPlaceholderText(/Enter the word cancel/i);
+		const input = screen.getByTestId('cancel-confirm-input');
 		await user.type(input, 'cancel');
 
 		await user.click(screen.getByRole('button', { name: /go back/i }));
@@ -84,19 +110,11 @@ describe('CancelSubscriptionBanner', () => {
 		await user.click(
 			screen.getByRole('button', { name: /cancel subscription/i }),
 		);
-		expect(screen.getByPlaceholderText(/Enter the word cancel/i)).toHaveValue('');
+		expect(screen.getByTestId('cancel-confirm-input')).toHaveValue('');
 	});
 
-	it('sends mailto to cloud-support with correct subject after typing "cancel"', async () => {
-		const realCreateElement = document.createElement.bind(document);
-		const mockClick = jest.fn();
-		const mockAnchor = { href: '', click: mockClick };
-		jest.spyOn(document, 'createElement').mockImplementation((tag: string) => {
-			if (tag === 'a') {
-				return mockAnchor as unknown as HTMLAnchorElement;
-			}
-			return realCreateElement(tag);
-		});
+	it('fires mailto via DOM-attached anchor and shows fallback view after confirming', async () => {
+		const { mockClick, appendSpy, removeSpy } = mockMailto();
 
 		const user = userEvent.setup({ pointerEventsCheck: 0 });
 		render(<CancelSubscriptionBanner />);
@@ -104,18 +122,85 @@ describe('CancelSubscriptionBanner', () => {
 		await user.click(
 			screen.getByRole('button', { name: /cancel subscription/i }),
 		);
+		await user.type(screen.getByTestId('cancel-confirm-input'), 'cancel');
+		await user.click(screen.getByTestId('cancel-subscription-confirm-btn'));
 
-		const input = screen.getByPlaceholderText(/Enter the word cancel/i);
-		await user.type(input, 'cancel');
+		const appendedAnchor = appendSpy.mock.calls
+			.map(([node]) => node)
+			.find(
+				(node): node is HTMLAnchorElement =>
+					node instanceof HTMLAnchorElement && node.href.startsWith('mailto:'),
+			);
+		expect(appendedAnchor).toBeDefined();
+		expect(mockClick).toHaveBeenCalledTimes(1);
+		expect(removeSpy.mock.calls.some(([node]) => node === appendedAnchor)).toBe(
+			true,
+		);
+
+		expect(
+			screen.getByText(/An email draft has been opened/i),
+		).toBeInTheDocument();
+		expect(screen.getByText('cloud-support@signoz.io')).toBeInTheDocument();
+		expect(screen.getByTestId('copy-email-template-btn')).toBeInTheDocument();
+		expect(screen.getByTestId('retry-mailto-btn')).toBeInTheDocument();
+	});
+
+	it('copies email template to clipboard when Copy button is clicked', async () => {
+		mockMailto();
+
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		render(<CancelSubscriptionBanner />);
 
 		await user.click(
 			screen.getByRole('button', { name: /cancel subscription/i }),
 		);
+		await user.type(screen.getByTestId('cancel-confirm-input'), 'cancel');
+		await user.click(screen.getByTestId('cancel-subscription-confirm-btn'));
 
-		expect(mockAnchor.href).toContain('mailto:cloud-support@signoz.io');
-		expect(mockAnchor.href).toContain('Cancel%20My%20SigNoz%20Subscription');
-		expect(mockClick).toHaveBeenCalledTimes(1);
+		await user.click(screen.getByTestId('copy-email-template-btn'));
 
-		jest.restoreAllMocks();
+		await waitFor(() =>
+			expect(screen.getByTestId('copy-email-template-btn')).toHaveTextContent(
+				'Copied!',
+			),
+		);
+	});
+
+	it('retry link is a native anchor with correct mailto href in fallback view', async () => {
+		mockMailto();
+
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		render(<CancelSubscriptionBanner />);
+
+		await user.click(
+			screen.getByRole('button', { name: /cancel subscription/i }),
+		);
+		await user.type(screen.getByTestId('cancel-confirm-input'), 'cancel');
+		await user.click(screen.getByTestId('cancel-subscription-confirm-btn'));
+
+		const retryLink = screen.getByTestId('retry-mailto-btn');
+		expect(retryLink.tagName).toBe('A');
+		expect(retryLink).toHaveAttribute(
+			'href',
+			expect.stringContaining('mailto:cloud-support@signoz.io'),
+		);
+	});
+
+	it('closes fallback view when Close is clicked and resets state', async () => {
+		mockMailto();
+
+		const user = userEvent.setup({ pointerEventsCheck: 0 });
+		render(<CancelSubscriptionBanner />);
+
+		await user.click(
+			screen.getByRole('button', { name: /cancel subscription/i }),
+		);
+		await user.type(screen.getByTestId('cancel-confirm-input'), 'cancel');
+		await user.click(screen.getByTestId('cancel-subscription-confirm-btn'));
+
+		await user.click(screen.getByRole('button', { name: /close/i }));
+		await waitFor(() =>
+			expect(screen.queryByRole('dialog')).not.toBeInTheDocument(),
+		);
 	});
 });

frontend/src/container/BillingContainer/CancelSubscriptionBanner.tsx

@@ -1,27 +1,100 @@
-import { useState } from 'react';
-import { SolidInfoCircle, Undo2, X } from '@signozhq/icons';
+import { useEffect, useRef, useState } from 'react';
+import {
+	CircleCheck,
+	Copy,
+	MailOpen,
+	SolidInfoCircle,
+	Undo2,
+	X,
+} from '@signozhq/icons';
 import { Button } from '@signozhq/ui/button';
 import { DialogWrapper } from '@signozhq/ui/dialog';
 import { Input } from '@signozhq/ui/input';
 import logEvent from 'api/common/logEvent';
 import { pick } from 'lodash-es';
 import { useAppContext } from 'providers/App/App';
+import { useCopyToClipboard } from 'react-use';
 import { getBaseUrl } from 'utils/basePath';
-
-import styles from './CancelSubscriptionBanner.module.scss';
 import { Color } from '@signozhq/design-tokens';
 
+import styles from './CancelSubscriptionBanner.module.scss';
+
+const SUPPORT_EMAIL = 'cloud-support@signoz.io';
+const MAX_MAILTO_URI_LENGTH = 1800;
+
+type DialogView = 'confirm' | 'fallback';
+
+function buildEmailBody(orgName: string, userEmail: string): string {
+	return [
+		'Hi SigNoz Team,',
+		'',
+		'I would like to cancel my SigNoz Cloud subscription.',
+		'Please find my account details below.',
+		'',
+		'Account Details:',
+		`  • SigNoz URL: ${getBaseUrl()}`,
+		...(orgName ? [`  • Organization: ${orgName}`] : []),
+		`  • Account Email: ${userEmail}`,
+		'',
+		'Reason for Cancellation:',
+		'[Please share the reason for cancellation]',
+		'',
+		'Additional feedback (optional):',
+		'[Any other feedback]',
+		'',
+		'Regards,',
+		'[user name or team name]',
+	].join('\n');
+}
+
+function buildMailtoUri(orgName: string, userEmail: string): string {
+	const subject = encodeURIComponent('Cancel My SigNoz Subscription');
+	const body = encodeURIComponent(buildEmailBody(orgName, userEmail));
+	const full = `mailto:${SUPPORT_EMAIL}?subject=${subject}&body=${body}`;
+	if (full.length <= MAX_MAILTO_URI_LENGTH) {
+		return full;
+	}
+	const shortBody = encodeURIComponent(
+		'Hi SigNoz Team,\n\nI would like to cancel my SigNoz Cloud subscription.\nPlease find my account details and reason for cancellation below.\n\n[Your details here]\n\nRegards,',
+	);
+	return `mailto:${SUPPORT_EMAIL}?subject=${subject}&body=${shortBody}`;
+}
+
+function openMailto(uri: string): void {
+	const link = document.createElement('a');
+	link.href = uri;
+	link.style.display = 'none';
+	document.body.appendChild(link);
+	link.click();
+	document.body.removeChild(link);
+}
+
 function CancelSubscriptionBanner(): JSX.Element {
-	const [open, setOpen] = useState(false);
+	const [dialogView, setDialogView] = useState<DialogView | null>(null);
 	const [confirmText, setConfirmText] = useState('');
+	const [copied, setCopied] = useState(false);
+	const [, copyToClipboard] = useCopyToClipboard();
+	const copyTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
 	const { user, org } = useAppContext();
 
+	useEffect(
+		() => (): void => {
+			if (copyTimerRef.current) {
+				clearTimeout(copyTimerRef.current);
+			}
+		},
+		[],
+	);
+
+	const orgName = org?.[0]?.displayName ?? '';
+	const userEmail = user?.email ?? '';
+
 	const handleOpenCancelDialog = (): void => {
 		void logEvent('Billing : Cancel Subscription Clicked', {
 			user: pick(user, ['email', 'displayName', 'role', 'organization']),
 			role: user?.role,
 		});
-		setOpen(true);
+		setDialogView('confirm');
 	};
 
 	const handleContactSupport = (): void => {
@@ -29,43 +102,41 @@ function CancelSubscriptionBanner(): JSX.Element {
 			user: pick(user, ['email', 'displayName', 'role', 'organization']),
 			role: user?.role,
 		});
-		const subject = encodeURIComponent('Cancel My SigNoz Subscription');
-		const orgName = org?.[0]?.displayName ?? '';
-		const body = encodeURIComponent(
-			[
-				'Hi SigNoz Team,',
-				'',
-				'I would like to cancel my SigNoz Cloud subscription.',
-				'Please find my account details below.',
-				'',
-				'Account Details:',
-				`  • SigNoz URL: ${getBaseUrl()}`,
-				...(orgName ? [`  • Organization: ${orgName}`] : []),
-				`  • Account Email: ${user?.email ?? ''}`,
-				'',
-				'Reason for Cancellation:',
-				'[Please share the reason for cancellation]',
-				'',
-				'Additional feedback (optional):',
-				'[Any other feedback]',
-				'',
-				'Regards,',
-				'[user name or team name]',
-			].join('\n'),
-		);
-		const link = document.createElement('a');
-		link.href = `mailto:cloud-support@signoz.io?subject=${subject}&body=${body}`;
-		link.click();
-		setOpen(false);
+		openMailto(buildMailtoUri(orgName, userEmail));
 		setConfirmText('');
+		setDialogView('fallback');
+	};
+
+	const handleCopyTemplate = (): void => {
+		void logEvent('Billing : Cancel Subscription Email Template Copied', {
+			user: pick(user, ['email', 'displayName', 'role', 'organization']),
+			role: user?.role,
+		});
+		copyToClipboard(buildEmailBody(orgName, userEmail));
+		setCopied(true);
+		if (copyTimerRef.current) {
+			clearTimeout(copyTimerRef.current);
+		}
+		copyTimerRef.current = setTimeout(() => setCopied(false), 2000);
+	};
+
+	const handleRetryMailto = (): void => {
+		void logEvent('Billing : Cancel Subscription Email Client Reopened', {
+			user: pick(user, ['email', 'displayName', 'role', 'organization']),
+			role: user?.role,
+		});
 	};
 
 	const handleClose = (): void => {
-		setOpen(false);
+		if (copyTimerRef.current) {
+			clearTimeout(copyTimerRef.current);
+		}
+		setDialogView(null);
 		setConfirmText('');
+		setCopied(false);
 	};
 
-	const footer = (
+	const confirmFooter = (
 		<>
 			<Button
 				variant="solid"
@@ -81,12 +152,19 @@ function CancelSubscriptionBanner(): JSX.Element {
 				prefix={<X size={14} />}
 				disabled={confirmText !== 'cancel'}
 				onClick={handleContactSupport}
+				data-testid="cancel-subscription-confirm-btn"
 			>
 				Cancel subscription
 			</Button>
 		</>
 	);
 
+	const fallbackFooter = (
+		<Button variant="solid" color="secondary" onClick={handleClose}>
+			Close
+		</Button>
+	);
+
 	return (
 		<>
 			<div className={styles.banner}>
@@ -111,27 +189,67 @@ function CancelSubscriptionBanner(): JSX.Element {
 				</Button>
 			</div>
 			<DialogWrapper
-				open={open}
+				open={dialogView !== null}
 				onOpenChange={handleClose}
 				title="Cancel your subscription?"
 				width="narrow"
 				showCloseButton={false}
-				footer={footer}
+				footer={dialogView === 'confirm' ? confirmFooter : fallbackFooter}
 			>
-				<div className={styles.dialogBody}>
-					<p className={styles.dialogDescription}>
-						Cancelling your subscription would stop your data from being ingested to
-						SigNoz. All the data that has been already sent will also be deleted.
-					</p>
-					<p className={styles.dialogConfirmLabel}>
-						Type <code>cancel</code> to confirm the cancellation.
-					</p>
-					<Input
-						placeholder="Enter the word cancel..."
-						value={confirmText}
-						onChange={(e): void => setConfirmText(e.target.value)}
-					/>
-				</div>
+				{dialogView === 'confirm' && (
+					<div className={styles.dialogBody}>
+						<p className={styles.dialogDescription}>
+							Cancelling your subscription would stop your data from being ingested to
+							SigNoz. All the data that has been already sent will also be deleted.
+						</p>
+						<p className={styles.dialogConfirmLabel}>
+							Type <code>cancel</code> to confirm the cancellation.
+						</p>
+						<Input
+							placeholder="Enter the word cancel..."
+							value={confirmText}
+							onChange={(e): void => setConfirmText(e.target.value)}
+							data-testid="cancel-confirm-input"
+						/>
+					</div>
+				)}
+				{dialogView === 'fallback' && (
+					<div className={styles.fallbackBody}>
+						<p className={styles.fallbackHint}>
+							An email draft has been opened. If it did not open, send your
+							cancellation request directly to:
+						</p>
+						<span className={styles.fallbackEmail}>{SUPPORT_EMAIL}</span>
+						<div className={styles.fallbackActions}>
+							<Button
+								variant="outlined"
+								color="secondary"
+								prefix={copied ? <CircleCheck size={14} /> : <Copy size={14} />}
+								onClick={handleCopyTemplate}
+								data-testid="copy-email-template-btn"
+							>
+								{copied ? 'Copied!' : 'Copy email template'}
+							</Button>
+							<Button
+								asChild
+								variant="outlined"
+								color="secondary"
+								data-testid="retry-mailto-btn"
+							>
+								<a
+									href={buildMailtoUri(orgName, userEmail)}
+									onClick={handleRetryMailto}
+									className={styles.retryLink}
+									target="_blank"
+									rel="noopener noreferrer"
+								>
+									<MailOpen size={14} />
+									Reopen email client
+								</a>
+							</Button>
+						</div>
+					</div>
+				)}
 			</DialogWrapper>
 		</>
 	);

frontend/src/pages/TraceDetailsV3/TraceDetailsHeader/NozButton.tsx

@@ -0,0 +1,46 @@
+import { useCallback } from 'react';
+import { useLocation } from 'react-router-dom';
+import { Button } from '@signozhq/ui/button';
+import { TooltipSimple } from '@signozhq/ui/tooltip';
+import logEvent from 'api/common/logEvent';
+import Noz from 'components/Noz/Noz';
+import { NOZ_TOOLTIP_TITLE } from 'components/Noz/Noz.constants';
+import {
+	AIAssistantEvents,
+	AIAssistantOpenSource,
+} from 'container/AIAssistant/events';
+import { normalizePage } from 'container/AIAssistant/hooks/useAIAssistantAnalyticsContext';
+import { openAIAssistant } from 'container/AIAssistant/store/useAIAssistantStore';
+import { useIsAIAssistantEnabled } from 'hooks/useIsAIAssistantEnabled';
+
+export default function NozButton(): JSX.Element | null {
+	const { pathname } = useLocation();
+	const isAIAssistantEnabled = useIsAIAssistantEnabled();
+
+	const handleOpenNoz = useCallback((): void => {
+		void logEvent(AIAssistantEvents.Opened, {
+			source: AIAssistantOpenSource.TraceDetails,
+			currentPage: normalizePage(pathname),
+		});
+		openAIAssistant();
+	}, [pathname]);
+
+	if (!isAIAssistantEnabled) {
+		return null;
+	}
+
+	return (
+		<TooltipSimple title={NOZ_TOOLTIP_TITLE}>
+			<Button
+				variant="ghost"
+				size="icon"
+				color="secondary"
+				className="noz-wave"
+				aria-label="Open Noz"
+				onClick={handleOpenNoz}
+			>
+				<Noz size={16} />
+			</Button>
+		</TooltipSimple>
+	);
+}

frontend/src/pages/TraceDetailsV3/TraceWaterfall/TraceWaterfallStates/Success/Filters/Filters.tsx

@@ -20,6 +20,7 @@ import { DEFAULT_ENTITY_VERSION } from 'constants/app';
 import { initialQueriesMap, PANEL_TYPES } from 'constants/queryBuilder';
 import { useGetQueryRange } from 'hooks/queryBuilder/useGetQueryRange';
 import { uniqBy } from 'lodash-es';
+import NozButton from 'pages/TraceDetailsV3/TraceDetailsHeader/NozButton';
 import { DataTypes } from 'types/api/queryBuilder/queryAutocompleteResponse';
 import { Query, TagFilter } from 'types/api/queryBuilder/queryBuilderData';
 import {
@@ -426,6 +427,8 @@ function Filters({
 					)}
 				</div>
 
+				<NozButton />
+
 				<div className={styles.highlightControl}>{highlightErrorsToggle}</div>
 			</div>
 		</TooltipProvider>

frontend/vite.config.ts

@@ -95,7 +95,7 @@ export default defineConfig(({ mode }): UserConfig => {
 				project: env.VITE_SENTRY_PROJECT_ID,
 				// Pin the sourcemap-upload release to the same value injected as
 				// process.env.VERSION so uploaded sourcemaps resolve. Ref: platform-pod#2393
-				release: { name: env.VITE_VERSION },
+				release: { name: env.VITE_VERSION, setCommits: { auto: true } },
 			}),
 		);
 	}

pkg/apiserver/signozapiserver/tracedetail.go

@@ -10,25 +10,6 @@ import (
 )
 
 func (provider *provider) addTraceDetailRoutes(router *mux.Router) error {
-	if err := router.Handle("/api/v3/traces/{traceID}/waterfall", handler.New(
-		provider.authzMiddleware.ViewAccess(provider.traceDetailHandler.GetWaterfall),
-		handler.OpenAPIDef{
-			ID:                  "GetWaterfall",
-			Tags:                []string{"tracedetail"},
-			Summary:             "Get waterfall view for a trace",
-			Description:         "Returns the waterfall view of spans for a given trace ID with tree structure, metadata, and windowed pagination",
-			Request:             new(spantypes.PostableWaterfall),
-			RequestContentType:  "application/json",
-			Response:            new(spantypes.GettableWaterfallTrace),
-			ResponseContentType: "application/json",
-			SuccessStatusCode:   http.StatusOK,
-			ErrorStatusCodes:    []int{http.StatusBadRequest, http.StatusNotFound},
-			SecuritySchemes:     newSecuritySchemes(types.RoleViewer),
-		},
-	)).Methods(http.MethodPost).GetError(); err != nil {
-		return err
-	}
-
 	if err := router.Handle("/api/v4/traces/{traceID}/waterfall", handler.New(
 		provider.authzMiddleware.ViewAccess(provider.traceDetailHandler.GetWaterfallV4),
 		handler.OpenAPIDef{

pkg/modules/cloudintegration/config.go

@@ -22,7 +22,7 @@ func newConfig() factory.Config {
 		Agent: AgentConfig{
 			// we will maintain the latest version of cloud integration agent from here,
 			// till we automate it externally or figure out a way to validate it.
-			Version: "v0.0.10",
+			Version: "v0.0.11",
 		},
 	}
 }

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/azure/appservice/icon.svg

@@ -0,0 +1 @@
+<svg id="b70acf0a-34b4-4bdf-9024-7496043ff915" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><defs><radialGradient id="e2cf8746-c9a8-4eee-86c2-4951983c6032" cx="13428.81" cy="3518.86" r="56.67" gradientTransform="translate(-2005.33 -518.83) scale(0.15)" gradientUnits="userSpaceOnUse"><stop offset="0.18" stop-color="#5ea0ef"/><stop offset="1" stop-color="#0078d4"/></radialGradient><linearGradient id="bdd213dd-d313-473c-8ff4-0133fd3a9033" x1="4.4" y1="11.48" x2="4.37" y2="7.53" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ccc"/><stop offset="1" stop-color="#fcfcfc"/></linearGradient><linearGradient id="afcc63c5-3649-4476-a742-bcb53a569f3c" x1="10.13" y1="15.45" x2="10.13" y2="11.9" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ccc"/><stop offset="1" stop-color="#fcfcfc"/></linearGradient><linearGradient id="bd873f0b-9954-4aa5-a3df-9f4c64e8729d" x1="14.18" y1="11.15" x2="14.18" y2="7.38" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#ccc"/><stop offset="1" stop-color="#fcfcfc"/></linearGradient></defs><title>Icon-web-41</title><path id="ee75dd06-1aca-4f76-9d11-d05a284020ad" d="M14.21,15.72A8.5,8.5,0,0,1,3.79,2.28l.09-.06a8.5,8.5,0,0,1,10.33,13.5" fill="url(#e2cf8746-c9a8-4eee-86c2-4951983c6032)"/><path d="M6.69,7.23A13,13,0,0,1,15.6,3.65a8.47,8.47,0,0,0-1.49-1.44,14.34,14.34,0,0,0-4.69,1.1A12.54,12.54,0,0,0,5.34,6.13,2.76,2.76,0,0,1,6.69,7.23Z" fill="#fff" opacity="0.6"/><path d="M2.48,10.65a17.86,17.86,0,0,0-.83,2.62,7.82,7.82,0,0,0,.62.92c.18.23.35.44.55.65A17.94,17.94,0,0,1,3.9,11.37,2.76,2.76,0,0,1,2.48,10.65Z" fill="#fff" opacity="0.6"/><path d="M3.46,6.11a12,12,0,0,1-.69-2.94,8.15,8.15,0,0,0-1.1,1.45A12.69,12.69,0,0,0,2.24,7,2.69,2.69,0,0,1,3.46,6.11Z" fill="#f2f2f2" opacity="0.55"/><circle cx="4.38" cy="8.68" r="2.73" fill="url(#bdd213dd-d313-473c-8ff4-0133fd3a9033)"/><path d="M8.36,13.67A1.77,1.77,0,0,1,8.9,12.4a11.88,11.88,0,0,1-2.53-1.86,2.74,2.74,0,0,1-1.49.83,13.1,13.1,0,0,0,1.45,1.28A12.12,12.12,0,0,0,8.38,13.9,1.79,1.79,0,0,1,8.36,13.67Z" fill="#f2f2f2" opacity="0.55"/><path d="M14.66,13.88a12,12,0,0,1-2.76-.32.41.41,0,0,1,0,.11,1.75,1.75,0,0,1-.51,1.24,13.69,13.69,0,0,0,3.42.24A8.21,8.21,0,0,0,16,13.81,11.5,11.5,0,0,1,14.66,13.88Z" fill="#f2f2f2" opacity="0.55"/><circle cx="10.13" cy="13.67" r="1.78" fill="url(#afcc63c5-3649-4476-a742-bcb53a569f3c)"/><path d="M12.32,8.93a1.83,1.83,0,0,1,.61-1A25.5,25.5,0,0,1,8.47,3.79a16.91,16.91,0,0,1-2-2.92,7.64,7.64,0,0,0-1.09.42A18.14,18.14,0,0,0,7.53,4.47,26.44,26.44,0,0,0,12.32,8.93Z" fill="#f2f2f2" opacity="0.7"/><circle cx="14.18" cy="9.27" r="1.89" fill="url(#bd873f0b-9954-4aa5-a3df-9f4c64e8729d)"/><path d="M17.35,10.54,17,10.37l0,0-.3-.16-.06,0L16.38,10l-.07,0L16,9.8a1.76,1.76,0,0,1-.64.92c.12.08.25.15.38.22l.08.05.35.19,0,0,.86.45h0a8.63,8.63,0,0,0,.29-1.11Z" fill="#f2f2f2" opacity="0.55"/><circle cx="4.38" cy="8.68" r="2.73" fill="url(#bdd213dd-d313-473c-8ff4-0133fd3a9033)"/><circle cx="10.13" cy="13.67" r="1.78" fill="url(#afcc63c5-3649-4476-a742-bcb53a569f3c)"/></svg>

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/azure/appservice/integration.json

@@ -0,0 +1,272 @@
+{
+  "id": "appservice",
+  "title": "App Services",
+  "icon": "file://icon.svg",
+  "overview": "file://overview.md",
+  "supportedSignals": {
+    "metrics": true,
+    "logs": true
+  },
+  "dataCollected": {
+    "metrics": [
+      {
+        "name": "azure_averagememoryworkingset_average",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_bytesreceived_total",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_bytessent_total",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_backendrequestcount_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_cputime_count",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_cputime_total",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_cputime_minimum",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_cputime_maximum",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_currentassemblies_average",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_filesystemusage_average",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_gen0collections_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_ge10collections_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_gen2collections_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_handles_average",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_healthcheckstatus_average",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_http101_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+
+      {
+        "name": "azure_http2xx_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+
+      {
+        "name": "azure_http3xx_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+
+      {
+        "name": "azure_http401_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+
+      {
+        "name": "azure_http403_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+
+      {
+        "name": "azure_http404_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+
+      {
+        "name": "azure_http406_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+
+      {
+        "name": "azure_http4xx_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+
+      {
+        "name": "azure_http5xx_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+
+      {
+        "name": "azure_httpresponsetime_average",
+        "unit": "Milliseconds",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_iootherbytespersecond_total",
+        "unit": "BytesPerSecond",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_iootheroperationspersecond_total",
+        "unit": "BytesPerSecond",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_ioreadbytespersecond_total",
+        "unit": "BytesPerSecond",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_ioreadoperationspersecond_total",
+        "unit": "BytesPerSecond",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_iowritebytespersecond_total",
+        "unit": "BytesPerSecond",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_iowriteoperationspersecond_total",
+        "unit": "BytesPerSecond",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_privatebytes_average",
+        "unit": "Bytes",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_requests_total",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_requestsinapplicationqueue_average",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_thread_average",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_totalappdomains_average",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      },
+      {
+        "name": "azure_totalappdomainsunloaded_average",
+        "unit": "Count",
+        "type": "Gauge",
+        "description": ""
+      }
+    ],
+    "logs": [
+      {
+        "name": "Resource ID",
+        "path": "resources.azure.resource.id",
+        "type": "string"
+      }
+    ]
+  },
+  "telemetryCollectionStrategy": {
+    "azure": {
+      "resourceProvider": "Microsoft.Web",
+      "resourceType": "sites",
+      "metrics": {},
+      "logs": {
+        "categoryGroups": ["allLogs"]
+      }
+    }
+  },
+  "assets": {
+    "dashboards": [
+      {
+        "id": "overview",
+        "title": "App Services Overview",
+        "description": "Overview of App Services metrics",
+        "definition": "file://assets/dashboards/overview.json"
+      }
+    ]
+  }
+}

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/azure/appservice/overview.md

@@ -0,0 +1,5 @@
+### Monitor Azure App Services with SigNoz
+
+Collect key App Services metrics and view them with an out of the box dashboard.
+
+Note: This integration DO NOT collect metrics for any database that was setup with your App Service (if any).

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/azure/virtualmachine/icon.svg

@@ -0,0 +1 @@
+<svg id="fd454f1c-5506-44b8-874e-8814b8b2f70b" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 18 18"><defs><linearGradient id="f34d9569-2bd0-4002-8f16-3d01d8106cb5" x1="8.88" y1="12.21" x2="8.88" y2="0.21" gradientUnits="userSpaceOnUse"><stop offset="0" stop-color="#0078d4"/><stop offset="0.82" stop-color="#5ea0ef"/></linearGradient><linearGradient id="bdb45a0b-eb58-4970-a60a-fb2ce314f866" x1="8.88" y1="16.84" x2="8.88" y2="12.21" gradientUnits="userSpaceOnUse"><stop offset="0.15" stop-color="#ccc"/><stop offset="1" stop-color="#707070"/></linearGradient></defs><title>Icon-compute-21</title><rect x="-0.12" y="0.21" width="18" height="12" rx="0.6" fill="url(#f34d9569-2bd0-4002-8f16-3d01d8106cb5)"/><polygon points="11.88 4.46 11.88 7.95 8.88 9.71 8.88 6.21 11.88 4.46" fill="#50e6ff"/><polygon points="11.88 4.46 8.88 6.22 5.88 4.46 8.88 2.71 11.88 4.46" fill="#c3f1ff"/><polygon points="8.88 6.22 8.88 9.71 5.88 7.95 5.88 4.46 8.88 6.22" fill="#9cebff"/><polygon points="5.88 7.95 8.88 6.21 8.88 9.71 5.88 7.95" fill="#c3f1ff"/><polygon points="11.88 7.95 8.88 6.21 8.88 9.71 11.88 7.95" fill="#9cebff"/><path d="M12.49,15.84c-1.78-.28-1.85-1.56-1.85-3.63H7.11c0,2.07-.06,3.35-1.84,3.63a1,1,0,0,0-.89,1h9A1,1,0,0,0,12.49,15.84Z" fill="url(#bdb45a0b-eb58-4970-a60a-fb2ce314f866)"/></svg>

pkg/modules/cloudintegration/implcloudintegration/fs/definitions/azure/virtualmachine/overview.md

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

pkg/modules/tracedetail/impltracedetail/handler.go

@@ -18,27 +18,6 @@ func NewHandler(module tracedetail.Module) tracedetail.Handler {
 	return &handler{module: module}
 }
 
-func (h *handler) GetWaterfall(rw http.ResponseWriter, r *http.Request) {
-	req := new(spantypes.PostableWaterfall)
-	if err := binding.JSON.BindBody(r.Body, req); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	if err := req.Validate(); err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	result, err := h.module.GetWaterfall(r.Context(), mux.Vars(r)["traceID"], req)
-	if err != nil {
-		render.Error(rw, err)
-		return
-	}
-
-	render.Success(rw, http.StatusOK, result)
-}
-
 func (h *handler) GetWaterfallV4(rw http.ResponseWriter, r *http.Request) {
 	req := new(spantypes.PostableWaterfall)
 	if err := binding.JSON.BindBody(r.Body, req); err != nil {
@@ -51,7 +30,7 @@ func (h *handler) GetWaterfallV4(rw http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	result, err := h.module.GetWaterfallV4(r.Context(), mux.Vars(r)["traceID"], req.SelectedSpanID, req.UncollapsedSpans, req.Limit)
+	result, err := h.module.GetWaterfallV4(r.Context(), mux.Vars(r)["traceID"], req.SelectedSpanID, req.UncollapsedSpans)
 	if err != nil {
 		render.Error(rw, err)
 		return

pkg/modules/tracedetail/impltracedetail/module.go

@@ -39,62 +39,16 @@ func NewModule(traceStore spantypes.TraceStore, providerSettings factory.Provide
 	return m
 }
 
-func (m *module) GetWaterfall(ctx context.Context, traceID string, req *spantypes.PostableWaterfall) (*spantypes.GettableWaterfallTrace, error) {
-	waterfallTrace, err := m.getTraceData(ctx, traceID)
-	if err != nil {
-		return nil, err
-	}
-
-	selectedSpans, uncollapsedSpans, selectedAllSpans := waterfallTrace.GetWaterfallSpans(
-		req.UncollapsedSpans,
-		req.SelectedSpanID,
-		min(req.Limit, m.config.Waterfall.MaxLimitToSelectAllSpans),
-		m.config.Waterfall.SpanPageSize,
-		m.config.Waterfall.MaxDepthToAutoExpand,
-	)
-
-	aggregationResults := make([]spantypes.SpanAggregationResult, 0, len(req.Aggregations))
-	for _, a := range req.Aggregations {
-		aggregationResults = append(aggregationResults, waterfallTrace.GetSpanAggregation(a.Aggregation, a.Field))
-	}
-
-	return spantypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, uncollapsedSpans, selectedAllSpans, aggregationResults), nil
-}
-
-// getTraceData fetches all spans for a trace and builds the WaterfallTrace.
-func (m *module) getTraceData(ctx context.Context, traceID string) (*spantypes.WaterfallTrace, error) {
-	summary, err := m.store.GetTraceSummary(ctx, traceID)
-	if err != nil {
-		return nil, err
-	}
-
-	spanItems, err := m.store.GetTraceSpans(ctx, traceID, summary)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(spanItems) == 0 {
-		return nil, spantypes.ErrTraceNotFound
-	}
-
-	nodes := make([]*spantypes.WaterfallSpan, len(spanItems))
-	for i := range spanItems {
-		nodes[i] = spanItems[i].ToWaterfallSpan(traceID)
-	}
-	return spantypes.NewWaterfallTraceFromSpans(nodes), nil
-}
-
 // GetWaterfallV4 is the OOM-safe V4 waterfall.
 // For large traces (NumSpans > effectiveLimit) it uses a two-step fetch:
 // minimal fields for all spans to build the tree, then full fields for the
 // visible window only. Aggregations are not returned.
-func (m *module) GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string, selectAllLimit uint) (*spantypes.GettableWaterfallTrace, error) {
+func (m *module) GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string) (*spantypes.GettableWaterfallTrace, error) {
 	summary, err := m.store.GetTraceSummary(ctx, traceID)
 	if err != nil {
 		return nil, err
 	}
-	effectiveLimit := min(selectAllLimit, m.config.Waterfall.MaxLimitToSelectAllSpans)
-	if summary.NumSpans > uint64(effectiveLimit) {
+	if summary.NumSpans > uint64(m.config.Waterfall.MaxLimitToSelectAllSpans) {
 		attrs := metric.WithAttributes(attrResponseType.String(attrResponseTypeWindowed))
 		m.metrics.waterfallRequestCount.Add(ctx, 1, attrs)
 		m.metrics.waterfallSpanCount.Add(ctx, int64(summary.NumSpans), attrs)
@@ -120,7 +74,7 @@ func (m *module) getFullWaterfall(ctx context.Context, traceID string, summary *
 	waterfallTrace := spantypes.NewWaterfallTraceFromSpans(nodes)
 	selectedSpans := waterfallTrace.GetAllSpans()
 
-	return spantypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, nil, true, nil), nil
+	return spantypes.NewGettableWaterfallTrace(waterfallTrace, selectedSpans, nil, true), nil
 }
 
 func (m *module) GetTraceAggregations(ctx context.Context, traceID string, req *spantypes.PostableTraceAggregations) (*spantypes.GettableTraceAggregations, error) {
@@ -215,7 +169,7 @@ func (m *module) getWindowedWaterfall(ctx context.Context, traceID, selectedSpan
 	spantypes.EnrichSelectedSpans(selectedSpans, fullSpans)
 
 	return spantypes.NewGettableWaterfallTrace(
-		waterfallTrace, selectedSpans, uncollapsedSpans, false, nil,
+		waterfallTrace, selectedSpans, uncollapsedSpans, false,
 	), nil
 }
 

pkg/modules/tracedetail/impltracedetail/waterfall_test.go

@@ -260,7 +260,7 @@ func TestGetSelectedSpans_MultipleRoots(t *testing.T) {
 	trace := getWaterfallTrace([]*spantypes.WaterfallSpan{root1, root2}, spanMap)
 	spans, _ := trace.GetSelectedSpans([]string{"root1", "root2"}, "root1", 500, 5)
 
-	traceRespnose := spantypes.NewGettableWaterfallTrace(trace, spans, nil, false, nil)
+	traceRespnose := spantypes.NewGettableWaterfallTrace(trace, spans, nil, false)
 
 	assert.Equal(t, []string{"root1", "child1", "root2", "child2"}, spanIDs(spans), "root1 subtree must precede root2 subtree")
 	assert.Equal(t, "svc-a", traceRespnose.RootServiceName, "metadata comes from first root")
@@ -567,7 +567,7 @@ func TestGetAllSpans(t *testing.T) {
 	)
 	trace := getWaterfallTrace([]*spantypes.WaterfallSpan{root}, nil)
 	spans := trace.GetAllSpans()
-	traceResponse := spantypes.NewGettableWaterfallTrace(trace, spans, nil, true, nil)
+	traceResponse := spantypes.NewGettableWaterfallTrace(trace, spans, nil, true)
 	assert.ElementsMatch(t, spanIDs(spans), []string{"root", "childA", "grandchildA", "leafA", "childB", "grandchildB", "leafB"})
 	assert.Equal(t, "svc", traceResponse.RootServiceName)
 	assert.Equal(t, "root-op", traceResponse.RootServiceEntryPoint)

pkg/modules/tracedetail/tracedetail.go

@@ -10,7 +10,6 @@ import (
 
 // Handler exposes HTTP handlers for trace detail APIs.
 type Handler interface {
-	GetWaterfall(http.ResponseWriter, *http.Request)
 	GetWaterfallV4(http.ResponseWriter, *http.Request)
 	GetTraceAggregations(http.ResponseWriter, *http.Request)
 	GetFlamegraph(http.ResponseWriter, *http.Request)
@@ -18,8 +17,7 @@ type Handler interface {
 
 // Module defines the business logic for trace detail operations.
 type Module interface {
-	GetWaterfall(ctx context.Context, traceID string, req *spantypes.PostableWaterfall) (*spantypes.GettableWaterfallTrace, error)
-	GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string, selectAllLimit uint) (*spantypes.GettableWaterfallTrace, error)
+	GetWaterfallV4(ctx context.Context, traceID string, selectedSpanID string, uncollapsedSpans []string) (*spantypes.GettableWaterfallTrace, error)
 	GetTraceAggregations(ctx context.Context, traceID string, req *spantypes.PostableTraceAggregations) (*spantypes.GettableTraceAggregations, error)
 	GetFlamegraph(ctx context.Context, traceID string, selectedSpanID string, selectFields []telemetrytypes.TelemetryFieldKey) (*spantypes.GettableFlamegraphTrace, error)
 }

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

@@ -898,223 +898,6 @@ func (r *ClickHouseReader) GetSpansForTrace(ctx context.Context, traceID string,
 	return searchScanResponses, nil
 }
 
-func (r *ClickHouseReader) GetWaterfallSpansForTraceWithMetadataCache(ctx context.Context, orgID valuer.UUID, traceID string) (*model.GetWaterfallSpansForTraceWithMetadataCache, error) {
-	cachedTraceData := new(model.GetWaterfallSpansForTraceWithMetadataCache)
-	err := r.cacheForTraceDetail.Get(ctx, orgID, strings.Join([]string{"getWaterfallSpansForTraceWithMetadata", traceID}, "-"), cachedTraceData)
-	if err != nil {
-		r.logger.Debug("error in retrieving getWaterfallSpansForTraceWithMetadata cache", errorsV2.Attr(err), "traceID", traceID)
-		return nil, err
-	}
-
-	if time.Since(time.UnixMilli(int64(cachedTraceData.EndTime))) < r.fluxIntervalForTraceDetail {
-		r.logger.Info("the trace end time falls under the flux interval, skipping getWaterfallSpansForTraceWithMetadata cache", "traceID", traceID)
-		return nil, errors.Errorf("the trace end time falls under the flux interval, skipping getWaterfallSpansForTraceWithMetadata cache, traceID: %s", traceID)
-	}
-
-	r.logger.Info("cache is successfully hit, applying cache for getWaterfallSpansForTraceWithMetadata", "traceID", traceID)
-	return cachedTraceData, nil
-}
-
-func (r *ClickHouseReader) GetWaterfallSpansForTraceWithMetadata(ctx context.Context, orgID valuer.UUID, traceID string, req *model.GetWaterfallSpansForTraceWithMetadataParams) (*model.GetWaterfallSpansForTraceWithMetadataResponse, error) {
-	response := new(model.GetWaterfallSpansForTraceWithMetadataResponse)
-	var startTime, endTime, durationNano, totalErrorSpans, totalSpans uint64
-	var spanIdToSpanNodeMap = map[string]*model.Span{}
-	var traceRoots []*model.Span
-	var serviceNameToTotalDurationMap = map[string]uint64{}
-	var serviceNameIntervalMap = map[string][]tracedetail.Interval{}
-	var hasMissingSpans bool
-
-	cachedTraceData, err := r.GetWaterfallSpansForTraceWithMetadataCache(ctx, orgID, traceID)
-	if err == nil {
-		startTime = cachedTraceData.StartTime
-		endTime = cachedTraceData.EndTime
-		durationNano = cachedTraceData.DurationNano
-		spanIdToSpanNodeMap = cachedTraceData.SpanIdToSpanNodeMap
-		serviceNameToTotalDurationMap = cachedTraceData.ServiceNameToTotalDurationMap
-		traceRoots = cachedTraceData.TraceRoots
-		totalSpans = cachedTraceData.TotalSpans
-		totalErrorSpans = cachedTraceData.TotalErrorSpans
-		hasMissingSpans = cachedTraceData.HasMissingSpans
-	}
-
-	if err != nil {
-		r.logger.Info("cache miss for getWaterfallSpansForTraceWithMetadata", "traceID", traceID)
-
-		searchScanResponses, err := r.GetSpansForTrace(ctx, traceID, fmt.Sprintf("SELECT DISTINCT ON (span_id) timestamp, duration_nano, span_id, trace_id, has_error, kind, resource_string_service$$name, name, links as references, attributes_string, attributes_number, attributes_bool, resources_string, events, status_message, status_code_string, kind_string FROM %s.%s WHERE trace_id=$1 and ts_bucket_start>=$2 and ts_bucket_start<=$3 ORDER BY timestamp ASC, name ASC", r.TraceDB, r.traceTableName))
-		if err != nil {
-			return nil, err
-		}
-		if len(searchScanResponses) == 0 {
-			return response, nil
-		}
-		totalSpans = uint64(len(searchScanResponses))
-		for _, item := range searchScanResponses {
-			ref := []model.OtelSpanRef{}
-			err := json.Unmarshal([]byte(item.References), &ref)
-			if err != nil {
-				r.logger.Error("getWaterfallSpansForTraceWithMetadata: error unmarshalling references", errorsV2.Attr(err), "traceID", traceID)
-				return nil, errorsV2.Newf(errorsV2.TypeInvalidInput, errorsV2.CodeInvalidInput, "getWaterfallSpansForTraceWithMetadata: error unmarshalling references %s", err.Error())
-			}
-
-			// merge attributes_number and attributes_bool to attributes_string
-			for k, v := range item.Attributes_bool {
-				item.Attributes_string[k] = fmt.Sprintf("%v", v)
-			}
-			for k, v := range item.Attributes_number {
-				item.Attributes_string[k] = strconv.FormatFloat(v, 'f', -1, 64)
-			}
-			for k, v := range item.Resources_string {
-				item.Attributes_string[k] = v
-			}
-
-			events := make([]model.Event, 0)
-			for _, event := range item.Events {
-				var eventMap model.Event
-				err = json.Unmarshal([]byte(event), &eventMap)
-				if err != nil {
-					r.logger.Error("Error unmarshalling events", errorsV2.Attr(err))
-					return nil, errorsV2.Newf(errorsV2.TypeInternal, errorsV2.CodeInternal, "getWaterfallSpansForTraceWithMetadata: error in unmarshalling events %s", err.Error())
-				}
-				events = append(events, eventMap)
-			}
-
-			startTimeUnixNano := uint64(item.TimeUnixNano.UnixNano())
-
-			jsonItem := model.Span{
-				SpanID:           item.SpanID,
-				TraceID:          item.TraceID,
-				ServiceName:      item.ServiceName,
-				Name:             item.Name,
-				Kind:             int32(item.Kind),
-				DurationNano:     item.DurationNano,
-				HasError:         item.HasError,
-				StatusMessage:    item.StatusMessage,
-				StatusCodeString: item.StatusCodeString,
-				SpanKind:         item.SpanKind,
-				References:       ref,
-				Events:           events,
-				TagMap:           item.Attributes_string,
-				Children:         make([]*model.Span, 0),
-				TimeUnixNano:     startTimeUnixNano, // Store nanoseconds temporarily
-			}
-
-			// metadata calculation
-			if startTime == 0 || startTimeUnixNano < startTime {
-				startTime = startTimeUnixNano
-			}
-			if endTime == 0 || (startTimeUnixNano+jsonItem.DurationNano) > endTime {
-				endTime = (startTimeUnixNano + jsonItem.DurationNano)
-			}
-			if durationNano == 0 || jsonItem.DurationNano > durationNano {
-				durationNano = jsonItem.DurationNano
-			}
-
-			if jsonItem.HasError {
-				totalErrorSpans = totalErrorSpans + 1
-			}
-
-			// collect the intervals for service for execution time calculation
-			serviceNameIntervalMap[jsonItem.ServiceName] =
-				append(serviceNameIntervalMap[jsonItem.ServiceName], tracedetail.Interval{StartTime: jsonItem.TimeUnixNano, Duration: jsonItem.DurationNano, Service: jsonItem.ServiceName})
-
-			// append to the span node map
-			spanIdToSpanNodeMap[jsonItem.SpanID] = &jsonItem
-		}
-
-		// traverse through the map and append each node to the children array of the parent node
-		// and add the missing spans
-		for _, spanNode := range spanIdToSpanNodeMap {
-			hasParentSpanNode := false
-			for _, reference := range spanNode.References {
-				if reference.RefType == "CHILD_OF" && reference.SpanId != "" {
-					hasParentSpanNode = true
-
-					if parentNode, exists := spanIdToSpanNodeMap[reference.SpanId]; exists {
-						parentNode.Children = append(parentNode.Children, spanNode)
-					} else {
-						// insert the missing span
-						missingSpan := model.Span{
-							SpanID:           reference.SpanId,
-							TraceID:          spanNode.TraceID,
-							ServiceName:      "",
-							Name:             "Missing Span",
-							TimeUnixNano:     spanNode.TimeUnixNano,
-							Kind:             0,
-							DurationNano:     spanNode.DurationNano,
-							HasError:         false,
-							StatusMessage:    "",
-							StatusCodeString: "",
-							SpanKind:         "",
-							Events:           make([]model.Event, 0),
-							Children:         make([]*model.Span, 0),
-						}
-						missingSpan.Children = append(missingSpan.Children, spanNode)
-						spanIdToSpanNodeMap[missingSpan.SpanID] = &missingSpan
-						traceRoots = append(traceRoots, &missingSpan)
-						hasMissingSpans = true
-					}
-				}
-			}
-			if !hasParentSpanNode && !tracedetail.ContainsWaterfallSpan(traceRoots, spanNode) {
-				traceRoots = append(traceRoots, spanNode)
-			}
-		}
-
-		// sort the trace roots to add missing spans at the right order
-		sort.Slice(traceRoots, func(i, j int) bool {
-			if traceRoots[i].TimeUnixNano == traceRoots[j].TimeUnixNano {
-				return traceRoots[i].Name < traceRoots[j].Name
-			}
-			return traceRoots[i].TimeUnixNano < traceRoots[j].TimeUnixNano
-		})
-
-		serviceNameToTotalDurationMap = tracedetail.CalculateServiceTime(serviceNameIntervalMap)
-
-		// TODO: set the span data (model.GetWaterfallSpansForTraceWithMetadataCache) in cache here
-		// removed existing cache usage since it was not getting used due to this bug https://github.com/SigNoz/engineering-pod/issues/4648
-		// and was causing out of memory issues https://github.com/SigNoz/engineering-pod/issues/4638
-	}
-
-	processingPostCache := time.Now()
-	// When req.Limit is 0 (not set by the client),  selectAllSpans is set to false
-	// preserving the old paged behaviour for backward compatibility
-	limit := min(req.Limit, tracedetail.MaxLimitToSelectAllSpans)
-	selectAllSpans := totalSpans <= uint64(limit)
-
-	var (
-		selectedSpans                          []*model.Span
-		uncollapsedSpans                       []string
-		rootServiceName, rootServiceEntryPoint string
-	)
-	if selectAllSpans {
-		selectedSpans, rootServiceName, rootServiceEntryPoint = tracedetail.GetAllSpans(traceRoots)
-	} else {
-		selectedSpans, uncollapsedSpans, rootServiceName, rootServiceEntryPoint = tracedetail.GetSelectedSpans(req.UncollapsedSpans, req.SelectedSpanID, traceRoots, spanIdToSpanNodeMap, req.IsSelectedSpanIDUnCollapsed)
-	}
-	r.logger.Info("getWaterfallSpansForTraceWithMetadata: processing post cache", "duration", time.Since(processingPostCache), "traceID", traceID)
-
-	// convert start timestamp to millis because right now frontend is expecting it in millis
-	for _, span := range selectedSpans {
-		span.TimeUnixNano = span.TimeUnixNano / 1000000
-	}
-
-	for serviceName, totalDuration := range serviceNameToTotalDurationMap {
-		serviceNameToTotalDurationMap[serviceName] = totalDuration / 1000000
-	}
-
-	response.Spans = selectedSpans
-	response.UncollapsedSpans = uncollapsedSpans // ignoring if all spans are returning
-	response.StartTimestampMillis = startTime / 1000000
-	response.EndTimestampMillis = endTime / 1000000
-	response.TotalSpansCount = totalSpans
-	response.TotalErrorSpansCount = totalErrorSpans
-	response.RootServiceName = rootServiceName
-	response.RootServiceEntryPoint = rootServiceEntryPoint
-	response.ServiceNameToTotalDurationMap = serviceNameToTotalDurationMap
-	response.HasMissingSpans = hasMissingSpans
-	response.HasMore = !selectAllSpans
-	return response, nil
-}
 
 func (r *ClickHouseReader) GetFlamegraphSpansForTraceCache(ctx context.Context, orgID valuer.UUID, traceID string) (*model.GetFlamegraphSpansForTraceCache, error) {
 	cachedTraceData := new(model.GetFlamegraphSpansForTraceCache)

pkg/query-service/app/http_handler.go

@@ -535,7 +535,7 @@ func (aH *APIHandler) RegisterRoutes(router *mux.Router, am *middleware.AuthZ) {
 	router.HandleFunc("/api/v2/traces/fields", am.ViewAccess(aH.traceFields)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v2/traces/fields", am.EditAccess(aH.updateTraceField)).Methods(http.MethodPost)
 	router.HandleFunc("/api/v2/traces/flamegraph/{traceId}", am.ViewAccess(aH.GetFlamegraphSpansForTrace)).Methods(http.MethodPost)
-	router.HandleFunc("/api/v2/traces/waterfall/{traceId}", am.ViewAccess(aH.GetWaterfallSpansForTraceWithMetadata)).Methods(http.MethodPost)
+
 
 	router.HandleFunc("/api/v1/version", am.OpenAccess(aH.getVersion)).Methods(http.MethodGet)
 	router.HandleFunc("/api/v1/features", am.ViewAccess(aH.getFeatureFlags)).Methods(http.MethodGet)
@@ -1446,39 +1446,6 @@ func (aH *APIHandler) SearchTraces(w http.ResponseWriter, r *http.Request) {
 
 }
 
-func (aH *APIHandler) GetWaterfallSpansForTraceWithMetadata(w http.ResponseWriter, r *http.Request) {
-	claims, err := authtypes.ClaimsFromContext(r.Context())
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	orgID, err := valuer.NewUUID(claims.OrgID)
-	if err != nil {
-		render.Error(w, err)
-		return
-	}
-	traceID := mux.Vars(r)["traceId"]
-	if traceID == "" {
-		render.Error(w, errors.NewInvalidInputf(errors.CodeInvalidInput, "traceID is required"))
-		return
-	}
-
-	req := new(model.GetWaterfallSpansForTraceWithMetadataParams)
-	err = json.NewDecoder(r.Body).Decode(&req)
-	if err != nil {
-		RespondError(w, model.BadRequest(err), nil)
-		return
-	}
-
-	result, apiErr := aH.reader.GetWaterfallSpansForTraceWithMetadata(r.Context(), orgID, traceID, req)
-	if apiErr != nil {
-		render.Error(w, apiErr)
-		return
-	}
-
-	aH.WriteJSON(w, r, result)
-}
-
 func (aH *APIHandler) GetFlamegraphSpansForTrace(w http.ResponseWriter, r *http.Request) {
 	claims, err := authtypes.ClaimsFromContext(r.Context())
 	if err != nil {

pkg/query-service/app/traces/tracedetail/waterfall.go

@@ -1,287 +0,0 @@
-package tracedetail
-
-import (
-	"maps"
-	"slices"
-	"sort"
-
-	"github.com/SigNoz/signoz/pkg/query-service/model"
-)
-
-var (
-	SPAN_LIMIT_PER_REQUEST_FOR_WATERFALL float64 = 500
-
-	maxDepthForSelectedSpanChildren int  = 5
-	MaxLimitToSelectAllSpans        uint = 10_000
-)
-
-type Interval struct {
-	StartTime uint64
-	Duration  uint64
-	Service   string
-}
-
-func mergeIntervals(intervals []Interval) []Interval {
-	if len(intervals) == 0 {
-		return nil
-	}
-
-	var merged []Interval
-	current := intervals[0]
-
-	for i := 1; i < len(intervals); i++ {
-		next := intervals[i]
-		if current.StartTime+current.Duration >= next.StartTime {
-			endTime := max(current.StartTime+current.Duration, next.StartTime+next.Duration)
-			current.Duration = endTime - current.StartTime
-		} else {
-			merged = append(merged, current)
-			current = next
-		}
-	}
-	// Add the last interval
-	merged = append(merged, current)
-
-	return merged
-}
-
-func ContainsWaterfallSpan(slice []*model.Span, item *model.Span) bool {
-	for _, v := range slice {
-		if v.SpanID == item.SpanID {
-			return true
-		}
-	}
-	return false
-}
-
-func findIndexForSelectedSpanFromPreOrder(spans []*model.Span, selectedSpanId string) int {
-	var selectedSpanIndex = -1
-
-	for index, span := range spans {
-		if span.SpanID == selectedSpanId {
-			selectedSpanIndex = index
-			break
-		}
-	}
-
-	return selectedSpanIndex
-}
-
-func getPathFromRootToSelectedSpanId(node *model.Span, selectedSpanId string) (bool, []string) {
-	spansFromRootToNode := []string{}
-
-	spansFromRootToNode = append(spansFromRootToNode, node.SpanID)
-	if node.SpanID == selectedSpanId {
-		return true, spansFromRootToNode
-	}
-
-	isPresentInSubtreeForTheNode := false
-	for _, child := range node.Children {
-		isPresentInThisSubtree, _spansFromRootToNode := getPathFromRootToSelectedSpanId(child, selectedSpanId)
-		// if the interested node is present in the given subtree then add the span node to uncollapsed node list
-		if isPresentInThisSubtree {
-			isPresentInSubtreeForTheNode = true
-			spansFromRootToNode = append(spansFromRootToNode, _spansFromRootToNode...)
-			break
-		}
-	}
-	return isPresentInSubtreeForTheNode, spansFromRootToNode
-}
-
-// traverseOpts holds the traversal configuration that remains constant
-// throughout the recursion. Per-call state (level, isPartOfPreOrder, etc.)
-// is passed as direct arguments.
-type traverseOpts struct {
-	uncollapsedSpans          map[string]struct{}
-	selectedSpanID            string
-	isSelectedSpanUncollapsed bool
-	selectAll                 bool
-}
-
-func traverseTrace(
-	span *model.Span,
-	opts traverseOpts,
-	level uint64,
-	isPartOfPreOrder bool,
-	hasSibling bool,
-	autoExpandDepth int,
-) ([]*model.Span, []string) {
-
-	preOrderTraversal := []*model.Span{}
-	autoExpandedSpans := []string{}
-
-	// sort the children to maintain the order across requests
-	sort.Slice(span.Children, func(i, j int) bool {
-		if span.Children[i].TimeUnixNano == span.Children[j].TimeUnixNano {
-			return span.Children[i].Name < span.Children[j].Name
-		}
-		return span.Children[i].TimeUnixNano < span.Children[j].TimeUnixNano
-	})
-
-	span.SubTreeNodeCount = 0
-	nodeWithoutChildren := model.Span{
-		SpanID:           span.SpanID,
-		TraceID:          span.TraceID,
-		ServiceName:      span.ServiceName,
-		TimeUnixNano:     span.TimeUnixNano,
-		Name:             span.Name,
-		Kind:             int32(span.Kind),
-		DurationNano:     span.DurationNano,
-		HasError:         span.HasError,
-		StatusMessage:    span.StatusMessage,
-		StatusCodeString: span.StatusCodeString,
-		SpanKind:         span.SpanKind,
-		References:       span.References,
-		Events:           span.Events,
-		TagMap:           span.TagMap,
-		Children:         make([]*model.Span, 0),
-		HasChildren:      len(span.Children) > 0,
-		Level:            level,
-		HasSiblings:      hasSibling,
-		SubTreeNodeCount: 0,
-	}
-
-	if isPartOfPreOrder {
-		preOrderTraversal = append(preOrderTraversal, &nodeWithoutChildren)
-	}
-
-	remainingAutoExpandDepth := 0
-	if span.SpanID == opts.selectedSpanID && opts.isSelectedSpanUncollapsed {
-		remainingAutoExpandDepth = maxDepthForSelectedSpanChildren
-	} else if autoExpandDepth > 0 {
-		remainingAutoExpandDepth = autoExpandDepth - 1
-	}
-
-	_, isAlreadyUncollapsed := opts.uncollapsedSpans[span.SpanID]
-	for index, child := range span.Children {
-		// A child is included in the pre-order output if its parent is uncollapsed
-		// OR if the child falls within MAX_DEPTH_FOR_SELECTED_SPAN_CHILDREN levels
-		// below the selected span.
-		isChildWithinMaxDepth := remainingAutoExpandDepth > 0
-		childIsPartOfPreOrder := opts.selectAll || (isPartOfPreOrder && (isAlreadyUncollapsed || isChildWithinMaxDepth))
-
-		if isPartOfPreOrder && isChildWithinMaxDepth && !isAlreadyUncollapsed {
-			if !slices.Contains(autoExpandedSpans, span.SpanID) {
-				autoExpandedSpans = append(autoExpandedSpans, span.SpanID)
-			}
-		}
-
-		_childTraversal, _autoExpanded := traverseTrace(child, opts, level+1, childIsPartOfPreOrder, index != (len(span.Children)-1), remainingAutoExpandDepth)
-		preOrderTraversal = append(preOrderTraversal, _childTraversal...)
-		autoExpandedSpans = append(autoExpandedSpans, _autoExpanded...)
-		nodeWithoutChildren.SubTreeNodeCount += child.SubTreeNodeCount + 1
-		span.SubTreeNodeCount += child.SubTreeNodeCount + 1
-	}
-
-	nodeWithoutChildren.SubTreeNodeCount += 1
-	return preOrderTraversal, autoExpandedSpans
-
-}
-
-func CalculateServiceTime(serviceIntervals map[string][]Interval) map[string]uint64 {
-	totalTimes := make(map[string]uint64)
-
-	for service, serviceIntervals := range serviceIntervals {
-		sort.Slice(serviceIntervals, func(i, j int) bool {
-			return serviceIntervals[i].StartTime < serviceIntervals[j].StartTime
-		})
-		mergedIntervals := mergeIntervals(serviceIntervals)
-		totalTime := uint64(0)
-		for _, interval := range mergedIntervals {
-			totalTime += interval.Duration
-		}
-		totalTimes[service] = totalTime
-	}
-
-	return totalTimes
-}
-
-func GetSelectedSpans(uncollapsedSpans []string, selectedSpanID string, traceRoots []*model.Span, spanIdToSpanNodeMap map[string]*model.Span, isSelectedSpanIDUnCollapsed bool) ([]*model.Span, []string, string, string) {
-
-	var preOrderTraversal = make([]*model.Span, 0)
-	var rootServiceName, rootServiceEntryPoint string
-
-	// create a map of uncollapsed spans for quick lookup
-	uncollapsedSpanMap := make(map[string]struct{})
-	for _, spanID := range uncollapsedSpans {
-		uncollapsedSpanMap[spanID] = struct{}{}
-	}
-
-	selectedSpanIndex := -1
-	for _, rootSpanID := range traceRoots {
-		if rootNode, exists := spanIdToSpanNodeMap[rootSpanID.SpanID]; exists {
-			present, spansFromRootToNode := getPathFromRootToSelectedSpanId(rootNode, selectedSpanID)
-			if present {
-				for _, spanID := range spansFromRootToNode {
-					if selectedSpanID == spanID && !isSelectedSpanIDUnCollapsed {
-						continue
-					}
-					uncollapsedSpanMap[spanID] = struct{}{}
-				}
-			}
-
-			opts := traverseOpts{
-				uncollapsedSpans:          uncollapsedSpanMap,
-				selectedSpanID:            selectedSpanID,
-				isSelectedSpanUncollapsed: isSelectedSpanIDUnCollapsed,
-			}
-			_preOrderTraversal, _autoExpanded := traverseTrace(rootNode, opts, 0, true, false, 0)
-			// Merge auto-expanded spans into updatedUncollapsedSpans for returning in response
-			for _, spanID := range _autoExpanded {
-				uncollapsedSpanMap[spanID] = struct{}{}
-			}
-			_selectedSpanIndex := findIndexForSelectedSpanFromPreOrder(_preOrderTraversal, selectedSpanID)
-
-			if _selectedSpanIndex != -1 {
-				selectedSpanIndex = _selectedSpanIndex + len(preOrderTraversal)
-			}
-
-			preOrderTraversal = append(preOrderTraversal, _preOrderTraversal...)
-
-			if rootServiceName == "" {
-				rootServiceName = rootNode.ServiceName
-			}
-
-			if rootServiceEntryPoint == "" {
-				rootServiceEntryPoint = rootNode.Name
-			}
-		}
-	}
-
-	// if we couldn't find the selectedSpan in the trace then defaulting the selected index to 0
-	if selectedSpanIndex == -1 && selectedSpanID != "" {
-		selectedSpanIndex = 0
-	}
-
-	// get the 0.4*[span limit] before the interested span index
-	startIndex := selectedSpanIndex - int(SPAN_LIMIT_PER_REQUEST_FOR_WATERFALL*0.4)
-	// get the 0.6*[span limit] after the intrested span index
-	endIndex := selectedSpanIndex + int(SPAN_LIMIT_PER_REQUEST_FOR_WATERFALL*0.6)
-
-	// adjust the sliding window according to the available left and right spaces.
-	if startIndex < 0 {
-		endIndex = endIndex - startIndex
-		startIndex = 0
-	}
-	if endIndex > len(preOrderTraversal) {
-		startIndex = startIndex - (endIndex - len(preOrderTraversal))
-		endIndex = len(preOrderTraversal)
-	}
-	if startIndex < 0 {
-		startIndex = 0
-	}
-
-	return preOrderTraversal[startIndex:endIndex], slices.Collect(maps.Keys(uncollapsedSpanMap)), rootServiceName, rootServiceEntryPoint
-}
-
-func GetAllSpans(traceRoots []*model.Span) (spans []*model.Span, rootServiceName, rootEntryPoint string) {
-	if len(traceRoots) > 0 {
-		rootServiceName = traceRoots[0].ServiceName
-		rootEntryPoint = traceRoots[0].Name
-	}
-	for _, root := range traceRoots {
-		childSpans, _ := traverseTrace(root, traverseOpts{selectAll: true}, 0, true, false, 0)
-		spans = append(spans, childSpans...)
-	}
-	return
-}

pkg/query-service/app/traces/tracedetail/waterfall_test.go

@@ -1,446 +0,0 @@
-// Package tracedetail tests — waterfall
-//
-// # Background
-//
-// The waterfall view renders a trace as a scrollable list of spans in
-// pre-order (parent before children, siblings left-to-right). Because a trace
-// can have thousands of spans, only a window of ~500 is returned per request.
-// The window is centred on the selected span.
-//
-// # Key concepts
-//
-// uncollapsedSpans
-//
-//	The set of span IDs the user has manually expanded in the UI.
-//	Only the direct children of an uncollapsed span are included in the
-//	output; grandchildren stay hidden until their parent is also uncollapsed.
-//	When multiple spans are uncollapsed their children are all visible at once.
-//
-// selectedSpanID
-//
-//	The span currently focused — set when the user clicks a span in the
-//	waterfall or selects one from the flamegraph.  The output window is always
-//	centred on this span.  The path from the trace root down to the selected
-//	span is automatically uncollapsed so ancestors are visible even if they are
-//	not in uncollapsedSpans.
-//
-// isSelectedSpanIDUnCollapsed
-//
-//	Controls whether the selected span's own children are shown:
-//	  true  — user expanded the span (click-to-open in waterfall or flamegraph);
-//	          direct children of the selected span are included.
-//	  false — user selected without expanding;
-//	          the span is visible but its children remain hidden.
-//
-// traceRoots
-//
-//	Root spans of the trace — spans with no parent in the current dataset.
-//	Normally one, but multiple roots are common when upstream services are
-//	not instrumented or their spans were not sampled/exported.
-
-package tracedetail
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/query-service/model"
-	"github.com/stretchr/testify/assert"
-)
-
-// Pre-order traversal is preserved: parent before children, siblings left-to-right.
-func TestGetSelectedSpans_PreOrderTraversal(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("child1", "svc", mkSpan("grandchild", "svc")),
-		mkSpan("child2", "svc"),
-	)
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{"root", "child1"}, "root", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, []string{"root", "child1", "grandchild", "child2"}, spanIDs(spans))
-}
-
-// Multiple roots: both trees are flattened into a single pre-order list with
-// root1's subtree before root2's. Service/entry-point come from the first root.
-//
-//	root1 svc-a          ← selected
-//	  └─ child1
-//	root2 svc-b
-//	  └─ child2
-//
-// Expected output order: root1 → child1 → root2 → child2
-func TestGetSelectedSpans_MultipleRoots(t *testing.T) {
-	root1 := mkSpan("root1", "svc-a", mkSpan("child1", "svc-a"))
-	root2 := mkSpan("root2", "svc-b", mkSpan("child2", "svc-b"))
-	spanMap := buildSpanMap(root1, root2)
-
-	spans, _, svcName, entryPoint := GetSelectedSpans([]string{"root1", "root2"}, "root1", []*model.Span{root1, root2}, spanMap, false)
-
-	assert.Equal(t, []string{"root1", "child1", "root2", "child2"}, spanIDs(spans), "root1 subtree must precede root2 subtree")
-	assert.Equal(t, "svc-a", svcName, "metadata comes from first root")
-	assert.Equal(t, "root1-op", entryPoint, "metadata comes from first root")
-}
-
-// Multiple spans uncollapsed simultaneously: children of all uncollapsed spans
-// are visible at once.
-//
-//	root
-//	  ├─ childA (uncollapsed) → grandchildA ✓
-//	  └─ childB (uncollapsed) → grandchildB ✓
-func TestGetSelectedSpans_MultipleUncollapsed(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("childA", "svc", mkSpan("grandchildA", "svc")),
-		mkSpan("childB", "svc", mkSpan("grandchildB", "svc")),
-	)
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{"root", "childA", "childB"}, "root", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, []string{"root", "childA", "grandchildA", "childB", "grandchildB"}, spanIDs(spans))
-}
-
-// Collapsing a span with other uncollapsed spans
-//
-// root
-// ├─ childA  (previously expanded — in uncollapsedSpans)
-// │    ├─ grandchild1 ✓
-// │    │    └─ greatGrandchild ✗  (grandchild1 not in uncollapsedSpans)
-// │    └─ grandchild2 ✓
-// └─ childB                        ← selected (not expanded)
-func TestGetSelectedSpans_ManualUncollapse(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("childA", "svc",
-			mkSpan("grandchild1", "svc", mkSpan("greatGrandchild", "svc")),
-			mkSpan("grandchild2", "svc"),
-		),
-		mkSpan("childB", "svc"),
-	)
-	spanMap := buildSpanMap(root)
-	// childA was expanded in a previous interaction; childB is now selected without expanding
-	spans, _, _, _ := GetSelectedSpans([]string{"childA"}, "childB", []*model.Span{root}, spanMap, false)
-
-	// path to childB auto-uncollpases root → childA and childB appear; childA is in
-	// uncollapsedSpans so its children appear; greatGrandchild stays hidden.
-	assert.Equal(t, []string{"root", "childA", "grandchild1", "grandchild2", "childB"}, spanIDs(spans))
-}
-
-// A collapsed span hides all children.
-func TestGetSelectedSpans_CollapsedSpan(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("child1", "svc"),
-		mkSpan("child2", "svc"),
-	)
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{}, "root", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, []string{"root"}, spanIDs(spans))
-}
-
-// Selecting a span auto-uncollpases the path from root to that span so it is visible.
-//
-//	root → parent → selected
-func TestGetSelectedSpans_PathToSelectedIsUncollapsed(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("parent", "svc",
-			mkSpan("selected", "svc"),
-		),
-	)
-	spanMap := buildSpanMap(root)
-	// no manually uncollapsed spans — path should still be opened
-	spans, _, _, _ := GetSelectedSpans([]string{}, "selected", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, []string{"root", "parent", "selected"}, spanIDs(spans))
-}
-
-// The path-to-selected spans are returned in updatedUncollapsedSpans.
-func TestGetSelectedSpans_PathReturnedInUncollapsed(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("parent", "svc",
-			mkSpan("selected", "svc"),
-		),
-	)
-	spanMap := buildSpanMap(root)
-	spans, uncollapsed, _, _ := GetSelectedSpans([]string{}, "selected", []*model.Span{root}, spanMap, false)
-
-	assert.ElementsMatch(t, []string{"root", "parent"}, uncollapsed)
-	assert.Equal(t, []string{"root", "parent", "selected"}, spanIDs(spans))
-}
-
-// Siblings of ancestors are rendered as collapsed nodes but their subtrees
-// must NOT be expanded.
-//
-//	root
-//	  ├─ unrelated → unrelated-child (✗)
-//	  └─ parent → selected
-func TestGetSelectedSpans_SiblingsNotExpanded(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("unrelated", "svc", mkSpan("unrelated-child", "svc")),
-		mkSpan("parent", "svc",
-			mkSpan("selected", "svc"),
-		),
-	)
-	spanMap := buildSpanMap(root)
-	spans, uncollapsed, _, _ := GetSelectedSpans([]string{}, "selected", []*model.Span{root}, spanMap, false)
-
-	// children of root sort alphabetically: parent < unrelated; unrelated-child stays hidden
-	assert.Equal(t, []string{"root", "parent", "selected", "unrelated"}, spanIDs(spans))
-	// only the path nodes are tracked as uncollapsed — unrelated is not
-	assert.ElementsMatch(t, []string{"root", "parent"}, uncollapsed)
-}
-
-// An unknown selectedSpanID must not panic; returns a window from index 0.
-func TestGetSelectedSpans_UnknownSelectedSpan(t *testing.T) {
-	root := mkSpan("root", "svc", mkSpan("child", "svc"))
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{}, "nonexistent", []*model.Span{root}, spanMap, false)
-	assert.Equal(t, []string{"root"}, spanIDs(spans))
-}
-
-// Test to check if Level, HasChildren, HasSiblings, and SubTreeNodeCount are populated correctly.
-//
-//	root          level=0, hasChildren=true,  hasSiblings=false, subTree=4
-//	  child1      level=1, hasChildren=true,  hasSiblings=true,  subTree=2
-//	    grandchild level=2, hasChildren=false, hasSiblings=false, subTree=1
-//	  child2      level=1, hasChildren=false, hasSiblings=false, subTree=1
-func TestGetSelectedSpans_SpanMetadata(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("child1", "svc", mkSpan("grandchild", "svc")),
-		mkSpan("child2", "svc"),
-	)
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{"root", "child1"}, "root", []*model.Span{root}, spanMap, false)
-
-	byID := map[string]*model.Span{}
-	for _, s := range spans {
-		byID[s.SpanID] = s
-	}
-
-	assert.Equal(t, uint64(0), byID["root"].Level)
-	assert.Equal(t, uint64(1), byID["child1"].Level)
-	assert.Equal(t, uint64(1), byID["child2"].Level)
-	assert.Equal(t, uint64(2), byID["grandchild"].Level)
-
-	assert.True(t, byID["root"].HasChildren)
-	assert.True(t, byID["child1"].HasChildren)
-	assert.False(t, byID["child2"].HasChildren)
-	assert.False(t, byID["grandchild"].HasChildren)
-
-	assert.False(t, byID["root"].HasSiblings, "root has no siblings")
-	assert.True(t, byID["child1"].HasSiblings, "child1 has sibling child2")
-	assert.False(t, byID["child2"].HasSiblings, "child2 is the last child")
-	assert.False(t, byID["grandchild"].HasSiblings, "grandchild has no siblings")
-
-	assert.Equal(t, uint64(4), byID["root"].SubTreeNodeCount)
-	assert.Equal(t, uint64(2), byID["child1"].SubTreeNodeCount)
-	assert.Equal(t, uint64(1), byID["grandchild"].SubTreeNodeCount)
-	assert.Equal(t, uint64(1), byID["child2"].SubTreeNodeCount)
-}
-
-// If the selected span is already in uncollapsedSpans AND isSelectedSpanIDUnCollapsed=true,
-func TestGetSelectedSpans_DuplicateInUncollapsed(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("selected", "svc", mkSpan("child", "svc")),
-	)
-	spanMap := buildSpanMap(root)
-	_, uncollapsed, _, _ := GetSelectedSpans(
-		[]string{"selected"}, // already present
-		"selected",
-		[]*model.Span{root}, spanMap,
-		true,
-	)
-
-	count := 0
-	for _, id := range uncollapsed {
-		if id == "selected" {
-			count++
-		}
-	}
-	assert.Equal(t, 1, count, "should appear once")
-}
-
-// makeChain builds a linear trace: span0 → span1 → … → span(n-1).
-// All span IDs are "span0", "span1", … so the caller can reference them by index.
-func makeChain(n int) (*model.Span, map[string]*model.Span, []string) {
-	spans := make([]*model.Span, n)
-	for i := n - 1; i >= 0; i-- {
-		if i == n-1 {
-			spans[i] = mkSpan(fmt.Sprintf("span%d", i), "svc")
-		} else {
-			spans[i] = mkSpan(fmt.Sprintf("span%d", i), "svc", spans[i+1])
-		}
-	}
-	uncollapsed := make([]string, n)
-	for i := range spans {
-		uncollapsed[i] = fmt.Sprintf("span%d", i)
-	}
-	return spans[0], buildSpanMap(spans[0]), uncollapsed
-}
-
-// The selected span is centred: 200 spans before it, 300 after (0.4 / 0.6 split).
-func TestGetSelectedSpans_WindowCentredOnSelected(t *testing.T) {
-	root, spanMap, uncollapsed := makeChain(600)
-	spans, _, _, _ := GetSelectedSpans(uncollapsed, "span300", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, 500, len(spans), "window should be 500 spans")
-	// window is [100, 600): span300 lands at position 200 (300 - 100)
-	assert.Equal(t, "span100", spans[0].SpanID, "window starts 200 before selected")
-	assert.Equal(t, "span300", spans[200].SpanID, "selected span at position 200 in window")
-	assert.Equal(t, "span599", spans[499].SpanID, "window ends 300 after selected")
-}
-
-// When the selected span is near the start, the window shifts right so no
-// negative index is used — the result is still 500 spans.
-func TestGetSelectedSpans_WindowShiftsAtStart(t *testing.T) {
-	root, spanMap, uncollapsed := makeChain(600)
-	spans, _, _, _ := GetSelectedSpans(uncollapsed, "span10", []*model.Span{root}, spanMap, false)
-
-	assert.Equal(t, 500, len(spans))
-	assert.Equal(t, "span0", spans[0].SpanID, "window clamped to start of trace")
-	assert.Equal(t, "span10", spans[10].SpanID, "selected span still in window")
-}
-
-// Auto-expanded span IDs from ALL branches are returned in
-// updatedUncollapsedSpans. Only internal nodes (spans with children) are
-// tracked — leaf spans are never added.
-//
-//	root (selected)
-//	  ├─ childA (internal ✓)
-//	  │    └─ grandchildA (internal ✓)
-//	  │         └─ leafA (leaf ✗)
-//	  └─ childB (internal ✓)
-//	       └─ grandchildB (internal ✓)
-//	            └─ leafB (leaf ✗)
-func TestGetSelectedSpans_AutoExpandedSpansReturnedInUncollapsed(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("childA", "svc",
-			mkSpan("grandchildA", "svc",
-				mkSpan("leafA", "svc"),
-			),
-		),
-		mkSpan("childB", "svc",
-			mkSpan("grandchildB", "svc",
-				mkSpan("leafB", "svc"),
-			),
-		),
-	)
-	spanMap := buildSpanMap(root)
-	_, uncollapsed, _, _ := GetSelectedSpans([]string{}, "root", []*model.Span{root}, spanMap, true)
-
-	// all internal nodes across both branches must be tracked
-	assert.Contains(t, uncollapsed, "root")
-	assert.Contains(t, uncollapsed, "childA", "internal node depth 1, branch A")
-	assert.Contains(t, uncollapsed, "childB", "internal node depth 1, branch B")
-	assert.Contains(t, uncollapsed, "grandchildA", "internal node depth 2, branch A")
-	assert.Contains(t, uncollapsed, "grandchildB", "internal node depth 2, branch B")
-	// leaves have no children to show — never added to uncollapsedSpans
-	assert.NotContains(t, uncollapsed, "leafA", "leaf spans are never added to uncollapsedSpans")
-	assert.NotContains(t, uncollapsed, "leafB", "leaf spans are never added to uncollapsedSpans")
-}
-
-// ─────────────────────────────────────────────────────────────────────────────
-// maxDepthForSelectedSpanChildren boundary tests
-// ─────────────────────────────────────────────────────────────────────────────
-
-// Depth is measured from the selected span, not the trace root.
-// Ancestors appear via the path-to-root logic, not the depth limit.
-// Each depth level has two children to confirm the limit is enforced on all
-// branches, not just the first.
-//
-//	root
-//	  └─ A                           ancestor ✓ (path-to-root)
-//	       └─ selected
-//	            ├─ d1a               depth 1 ✓
-//	            │    ├─ d2a          depth 2 ✓
-//	            │    │    ├─ d3a     depth 3 ✓
-//	            │    │    │    ├─ d4a   depth 4 ✓
-//	            │    │    │    │    ├─ d5a  depth 5 ✓
-//	            │    │    │    │    │    └─ d6a  depth 6 ✗
-//	            │    │    │    │    └─ d5b  depth 5 ✓
-//	            │    │    │    └─ d4b   depth 4 ✓
-//	            │    │    └─ d3b     depth 3 ✓
-//	            │    └─ d2b          depth 2 ✓
-//	            └─ d1b               depth 1 ✓
-func TestGetSelectedSpans_DepthCountedFromSelectedSpan(t *testing.T) {
-	selected := mkSpan("selected", "svc",
-		mkSpan("d1a", "svc",
-			mkSpan("d2a", "svc",
-				mkSpan("d3a", "svc",
-					mkSpan("d4a", "svc",
-						mkSpan("d5a", "svc",
-							mkSpan("d6a", "svc"), // depth 6 — excluded
-						),
-						mkSpan("d5b", "svc"), // depth 5 — included
-					),
-					mkSpan("d4b", "svc"), // depth 4 — included
-				),
-				mkSpan("d3b", "svc"), // depth 3 — included
-			),
-			mkSpan("d2b", "svc"), // depth 2 — included
-		),
-		mkSpan("d1b", "svc"), // depth 1 — included
-	)
-	root := mkSpan("root", "svc", mkSpan("A", "svc", selected))
-
-	spanMap := buildSpanMap(root)
-	spans, _, _, _ := GetSelectedSpans([]string{}, "selected", []*model.Span{root}, spanMap, true)
-	ids := spanIDs(spans)
-
-	assert.Contains(t, ids, "root", "ancestor shown via path-to-root")
-	assert.Contains(t, ids, "A", "ancestor shown via path-to-root")
-	for _, id := range []string{"d1a", "d1b", "d2a", "d2b", "d3a", "d3b", "d4a", "d4b", "d5a", "d5b"} {
-		assert.Contains(t, ids, id, "depth ≤ 5 — must be included")
-	}
-	assert.NotContains(t, ids, "d6a", "depth 6 > limit — excluded")
-}
-
-func TestGetAllSpans(t *testing.T) {
-	root := mkSpan("root", "svc",
-		mkSpan("childA", "svc",
-			mkSpan("grandchildA", "svc",
-				mkSpan("leafA", "svc2"),
-			),
-		),
-		mkSpan("childB", "svc3",
-			mkSpan("grandchildB", "svc",
-				mkSpan("leafB", "svc2"),
-			),
-		),
-	)
-	spans, rootServiceName, rootEntryPoint := GetAllSpans([]*model.Span{root})
-	assert.ElementsMatch(t, spanIDs(spans), []string{"root", "childA", "grandchildA", "leafA", "childB", "grandchildB", "leafB"})
-	assert.Equal(t, rootServiceName, "svc")
-	assert.Equal(t, rootEntryPoint, "root-op")
-}
-
-func mkSpan(id, service string, children ...*model.Span) *model.Span {
-	return &model.Span{
-		SpanID:      id,
-		ServiceName: service,
-		Name:        id + "-op",
-		Children:    children,
-	}
-}
-
-// spanIDs returns SpanIDs in order.
-func spanIDs(spans []*model.Span) []string {
-	ids := make([]string, len(spans))
-	for i, s := range spans {
-		ids[i] = s.SpanID
-	}
-	return ids
-}
-
-// buildSpanMap indexes every span in a set of trees by SpanID.
-func buildSpanMap(roots ...*model.Span) map[string]*model.Span {
-	m := map[string]*model.Span{}
-	var walk func(*model.Span)
-	walk = func(s *model.Span) {
-		m[s.SpanID] = s
-		for _, c := range s.Children {
-			walk(c)
-		}
-	}
-	for _, r := range roots {
-		walk(r)
-	}
-	return m
-}

pkg/query-service/interfaces/interface.go

@@ -43,7 +43,6 @@ type Reader interface {
 
 	// Search Interfaces
 	SearchTraces(ctx context.Context, params *model.SearchTracesParams) (*[]model.SearchSpansResult, error)
-	GetWaterfallSpansForTraceWithMetadata(ctx context.Context, orgID valuer.UUID, traceID string, req *model.GetWaterfallSpansForTraceWithMetadataParams) (*model.GetWaterfallSpansForTraceWithMetadataResponse, error)
 	GetFlamegraphSpansForTrace(ctx context.Context, orgID valuer.UUID, traceID string, req *model.GetFlamegraphSpansForTraceParams) (*model.GetFlamegraphSpansForTraceResponse, error)
 
 	// Setter Interfaces

pkg/query-service/model/cacheable.go

@@ -2,57 +2,10 @@ package model
 
 import (
 	"encoding/json"
-	"maps"
 
 	"github.com/SigNoz/signoz/pkg/types/cachetypes"
 )
 
-type GetWaterfallSpansForTraceWithMetadataCache struct {
-	StartTime                     uint64            `json:"startTime"`
-	EndTime                       uint64            `json:"endTime"`
-	DurationNano                  uint64            `json:"durationNano"`
-	TotalSpans                    uint64            `json:"totalSpans"`
-	TotalErrorSpans               uint64            `json:"totalErrorSpans"`
-	ServiceNameToTotalDurationMap map[string]uint64 `json:"serviceNameToTotalDurationMap"`
-	SpanIdToSpanNodeMap           map[string]*Span  `json:"spanIdToSpanNodeMap"`
-	TraceRoots                    []*Span           `json:"traceRoots"`
-	HasMissingSpans               bool              `json:"hasMissingSpans"`
-}
-
-func (c *GetWaterfallSpansForTraceWithMetadataCache) Clone() cachetypes.Cacheable {
-	copyOfServiceNameToTotalDurationMap := make(map[string]uint64)
-	maps.Copy(copyOfServiceNameToTotalDurationMap, c.ServiceNameToTotalDurationMap)
-
-	copyOfSpanIdToSpanNodeMap := make(map[string]*Span)
-	maps.Copy(copyOfSpanIdToSpanNodeMap, c.SpanIdToSpanNodeMap)
-
-	copyOfTraceRoots := make([]*Span, len(c.TraceRoots))
-	copy(copyOfTraceRoots, c.TraceRoots)
-	return &GetWaterfallSpansForTraceWithMetadataCache{
-		StartTime:                     c.StartTime,
-		EndTime:                       c.EndTime,
-		DurationNano:                  c.DurationNano,
-		TotalSpans:                    c.TotalSpans,
-		TotalErrorSpans:               c.TotalErrorSpans,
-		ServiceNameToTotalDurationMap: copyOfServiceNameToTotalDurationMap,
-		SpanIdToSpanNodeMap:           copyOfSpanIdToSpanNodeMap,
-		TraceRoots:                    copyOfTraceRoots,
-		HasMissingSpans:               c.HasMissingSpans,
-	}
-}
-
-func (c *GetWaterfallSpansForTraceWithMetadataCache) Cost() int64 {
-	const perSpanBytes = 256
-	return int64(c.TotalSpans) * perSpanBytes
-}
-
-func (c *GetWaterfallSpansForTraceWithMetadataCache) MarshalBinary() (data []byte, err error) {
-	return json.Marshal(c)
-}
-func (c *GetWaterfallSpansForTraceWithMetadataCache) UnmarshalBinary(data []byte) error {
-	return json.Unmarshal(data, c)
-}
-
 type GetFlamegraphSpansForTraceCache struct {
 	StartTime     uint64              `json:"startTime"`
 	EndTime       uint64              `json:"endTime"`

pkg/query-service/model/queryParams.go

@@ -331,13 +331,6 @@ type SearchTracesParams struct {
 	MaxSpansInTrace  int    `json:"maxSpansInTrace"`
 }
 
-type GetWaterfallSpansForTraceWithMetadataParams struct {
-	SelectedSpanID              string   `json:"selectedSpanId"`
-	IsSelectedSpanIDUnCollapsed bool     `json:"isSelectedSpanIDUnCollapsed"`
-	UncollapsedSpans            []string `json:"uncollapsedSpans"`
-	Limit                       uint     `json:"limit"`
-}
-
 type GetFlamegraphSpansForTraceParams struct {
 	SelectedSpanID  string                             `json:"selectedSpanId"`
 	Limit           uint                               `json:"limit"`

pkg/query-service/model/response.go

@@ -332,22 +332,6 @@ func (s *FlamegraphSpan) SetRequestedFields(item SpanItemV2, fields []telemetryt
 	}
 }
 
-type GetWaterfallSpansForTraceWithMetadataResponse struct {
-	StartTimestampMillis          uint64            `json:"startTimestampMillis"`
-	EndTimestampMillis            uint64            `json:"endTimestampMillis"`
-	DurationNano                  uint64            `json:"durationNano"`
-	RootServiceName               string            `json:"rootServiceName"`
-	RootServiceEntryPoint         string            `json:"rootServiceEntryPoint"`
-	TotalSpansCount               uint64            `json:"totalSpansCount"`
-	TotalErrorSpansCount          uint64            `json:"totalErrorSpansCount"`
-	ServiceNameToTotalDurationMap map[string]uint64 `json:"serviceNameToTotalDurationMap"`
-	Spans                         []*Span           `json:"spans"`
-	HasMissingSpans               bool              `json:"hasMissingSpans"`
-	// this is needed for frontend and query service sync
-	UncollapsedSpans []string `json:"uncollapsedSpans"`
-	HasMore          bool     `json:"hasMore"`
-}
-
 type GetFlamegraphSpansForTraceResponse struct {
 	StartTimestampMillis uint64              `json:"startTimestampMillis"`
 	EndTimestampMillis   uint64              `json:"endTimestampMillis"`

pkg/types/cloudintegrationtypes/serviceid.go

@@ -27,6 +27,8 @@ var (
 	// Azure services.
 	AzureServiceStorageAccountsBlob = ServiceID{valuer.NewString("storageaccountsblob")}
 	AzureServiceCDNProfile          = ServiceID{valuer.NewString("cdnprofile")}
+	AzureServiceVirtualMachine      = ServiceID{valuer.NewString("virtualmachine")}
+	AzureServiceAppService          = ServiceID{valuer.NewString("appservice")}
 	AzureServiceContainerApp        = ServiceID{valuer.NewString("containerapp")}
 	AzureServiceAKS                 = ServiceID{valuer.NewString("aks")}
 )
@@ -48,6 +50,8 @@ func (ServiceID) Enum() []any {
 		AWSServiceSQS,
 		AzureServiceStorageAccountsBlob,
 		AzureServiceCDNProfile,
+		AzureServiceVirtualMachine,
+		AzureServiceAppService,
 		AzureServiceContainerApp,
 		AzureServiceAKS,
 	}
@@ -73,6 +77,8 @@ var SupportedServices = map[CloudProviderType][]ServiceID{
 	CloudProviderTypeAzure: {
 		AzureServiceStorageAccountsBlob,
 		AzureServiceCDNProfile,
+		AzureServiceVirtualMachine,
+		AzureServiceAppService,
 		AzureServiceContainerApp,
 		AzureServiceAKS,
 	},

pkg/types/spantypes/aggregation_test.go

@@ -1,251 +0,0 @@
-package spantypes
-
-import (
-	"testing"
-
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
-	"github.com/stretchr/testify/assert"
-)
-
-// mkASpan builds a WaterfallSpan with timing and field data for analytics tests.
-func mkASpan(id string, resource map[string]string, attributes map[string]any, startNs, durationNs uint64) *WaterfallSpan {
-	return &WaterfallSpan{
-		SpanID:       id,
-		Resource:     resource,
-		Attributes:   attributes,
-		TimeUnix:     startNs,
-		DurationNano: durationNs,
-		Children:     make([]*WaterfallSpan, 0),
-	}
-}
-
-func buildTraceFromSpans(spans ...*WaterfallSpan) *WaterfallTrace {
-	spanMap := make(map[string]*WaterfallSpan, len(spans))
-	var startTime, endTime uint64
-	initialized := false
-	for _, s := range spans {
-		spanMap[s.SpanID] = s
-		if !initialized || s.TimeUnix < startTime {
-			startTime = s.TimeUnix
-			initialized = true
-		}
-		if end := s.TimeUnix + s.DurationNano; end > endTime {
-			endTime = end
-		}
-	}
-	return NewWaterfallTrace(startTime, endTime, uint64(len(spanMap)), 0, spanMap, nil, false)
-}
-
-var (
-	fieldServiceName = telemetrytypes.TelemetryFieldKey{
-		Name:         "service.name",
-		FieldContext: telemetrytypes.FieldContextResource,
-	}
-	fieldHTTPMethod = telemetrytypes.TelemetryFieldKey{
-		Name:         "http.method",
-		FieldContext: telemetrytypes.FieldContextAttribute,
-	}
-	fieldCached = telemetrytypes.TelemetryFieldKey{
-		Name:         "db.cached",
-		FieldContext: telemetrytypes.FieldContextAttribute,
-	}
-)
-
-func TestGetSpanAggregation_SpanCount(t *testing.T) {
-	tests := []struct {
-		name  string
-		trace *WaterfallTrace
-		field telemetrytypes.TelemetryFieldKey
-		want  map[string]uint64
-	}{
-		{
-			name: "counts by resource field",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", map[string]string{"service.name": "frontend"}, nil, 0, 10),
-				mkASpan("s2", map[string]string{"service.name": "frontend"}, nil, 10, 5),
-				mkASpan("s3", map[string]string{"service.name": "backend"}, nil, 20, 8),
-			),
-			field: fieldServiceName,
-			want:  map[string]uint64{"frontend": 2, "backend": 1},
-		},
-		{
-			name: "counts by string attribute field",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", nil, map[string]any{"http.method": "GET"}, 0, 10),
-				mkASpan("s2", nil, map[string]any{"http.method": "POST"}, 10, 5),
-				mkASpan("s3", nil, map[string]any{"http.method": "GET"}, 20, 8),
-			),
-			field: fieldHTTPMethod,
-			want:  map[string]uint64{"GET": 2, "POST": 1},
-		},
-		{
-			name: "counts by boolean attribute field",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", nil, map[string]any{"db.cached": true}, 0, 10),
-				mkASpan("s2", nil, map[string]any{"db.cached": false}, 10, 5),
-				mkASpan("s3", nil, map[string]any{"db.cached": true}, 20, 8),
-			),
-			field: fieldCached,
-			want:  map[string]uint64{"true": 2, "false": 1},
-		},
-		{
-			name: "spans missing the field are excluded",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", map[string]string{"service.name": "frontend"}, nil, 0, 10),
-				mkASpan("s2", map[string]string{}, nil, 10, 5), // no service.name
-				mkASpan("s3", map[string]string{"service.name": "backend"}, nil, 20, 8),
-			),
-			field: fieldServiceName,
-			want:  map[string]uint64{"frontend": 1, "backend": 1},
-		},
-		{
-			// empty string is a valid field value — counted under the "" key, unlike a missing field
-			name: "span with empty service.name is counted under empty string key",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", map[string]string{"service.name": "frontend"}, nil, 0, 10),
-				mkASpan("s2", map[string]string{"service.name": ""}, nil, 10, 5),
-				mkASpan("s3", map[string]string{"service.name": "backend"}, nil, 20, 8),
-			),
-			field: fieldServiceName,
-			want:  map[string]uint64{"frontend": 1, "backend": 1, "": 1},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			result := tc.trace.GetSpanAggregation(SpanAggregationSpanCount, tc.field)
-			assert.Equal(t, tc.field, result.Field)
-			assert.Equal(t, SpanAggregationSpanCount, result.Aggregation)
-			assert.Equal(t, tc.want, result.Value)
-		})
-	}
-}
-
-func TestGetSpanAggregation_Duration(t *testing.T) {
-	tests := []struct {
-		name  string
-		trace *WaterfallTrace
-		field telemetrytypes.TelemetryFieldKey
-		want  map[string]uint64
-	}{
-		{
-			name: "non-overlapping spans — merged equals sum",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", map[string]string{"service.name": "frontend"}, nil, 0, 100),
-				mkASpan("s2", map[string]string{"service.name": "frontend"}, nil, 100, 50),
-				mkASpan("s3", map[string]string{"service.name": "backend"}, nil, 0, 80),
-			),
-			field: fieldServiceName,
-			want:  map[string]uint64{"frontend": 150, "backend": 80},
-		},
-		{
-			name: "non-overlapping attribute groups — merged equals sum",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", nil, map[string]any{"http.method": "GET"}, 0, 30),
-				mkASpan("s2", nil, map[string]any{"http.method": "GET"}, 50, 20),
-				mkASpan("s3", nil, map[string]any{"http.method": "POST"}, 0, 70),
-			),
-			field: fieldHTTPMethod,
-			want:  map[string]uint64{"GET": 50, "POST": 70},
-		},
-		{
-			name: "overlapping spans — non-overlapping interval merge",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", map[string]string{"service.name": "svc"}, nil, 0, 10),
-				mkASpan("s2", map[string]string{"service.name": "svc"}, nil, 5, 10),
-			),
-			field: fieldServiceName,
-			want:  map[string]uint64{"svc": 15}, // [0,10] ∪ [5,15] = [0,15]
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			result := tc.trace.GetSpanAggregation(SpanAggregationDuration, tc.field)
-			assert.Equal(t, tc.field, result.Field)
-			assert.Equal(t, SpanAggregationDuration, result.Aggregation)
-			assert.Equal(t, tc.want, result.Value)
-		})
-	}
-}
-
-func TestGetSpanAggregation_ExecutionTimePercentage(t *testing.T) {
-	tests := []struct {
-		name  string
-		trace *WaterfallTrace
-		field telemetrytypes.TelemetryFieldKey
-		want  map[string]uint64
-	}{
-		{
-			// trace [0,30]: svc occupies [0,10]+[20,30]=20 → 20*100/30 = 66%
-			name: "non-overlapping spans",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", map[string]string{"service.name": "svc"}, nil, 0, 10),
-				mkASpan("s2", map[string]string{"service.name": "svc"}, nil, 20, 10),
-			),
-			field: fieldServiceName,
-			want:  map[string]uint64{"svc": 66},
-		},
-		{
-			// trace [0,15]: svc [0,15]=15 → 100%
-			name: "partially overlapping spans",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", map[string]string{"service.name": "svc"}, nil, 0, 10),
-				mkASpan("s2", map[string]string{"service.name": "svc"}, nil, 5, 10),
-			),
-			field: fieldServiceName,
-			want:  map[string]uint64{"svc": 100},
-		},
-		{
-			// trace [0,20]: outer absorbs inner → 100%
-			name: "fully contained span",
-			trace: buildTraceFromSpans(
-				mkASpan("outer", map[string]string{"service.name": "svc"}, nil, 0, 20),
-				mkASpan("inner", map[string]string{"service.name": "svc"}, nil, 5, 5),
-			),
-			field: fieldServiceName,
-			want:  map[string]uint64{"svc": 100},
-		},
-		{
-			// trace [0,30]: svc [0,15]+[20,30]=25 → 25*100/30 = 83%
-			name: "three spans with two merges",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", map[string]string{"service.name": "svc"}, nil, 0, 10),
-				mkASpan("s2", map[string]string{"service.name": "svc"}, nil, 5, 10),
-				mkASpan("s3", map[string]string{"service.name": "svc"}, nil, 20, 10),
-			),
-			field: fieldServiceName,
-			want:  map[string]uint64{"svc": 83},
-		},
-		{
-			// trace [0,28]: frontend [0,15]=15 → 53%, backend [0,5]+[20,28]=13 → 46%
-			name: "independent groups are computed separately",
-			trace: buildTraceFromSpans(
-				mkASpan("a1", map[string]string{"service.name": "frontend"}, nil, 0, 10),
-				mkASpan("a2", map[string]string{"service.name": "frontend"}, nil, 5, 10),
-				mkASpan("b1", map[string]string{"service.name": "backend"}, nil, 0, 5),
-				mkASpan("b2", map[string]string{"service.name": "backend"}, nil, 20, 8),
-			),
-			field: fieldServiceName,
-			want:  map[string]uint64{"frontend": 53, "backend": 46},
-		},
-		{
-			// trace [100,150]: svc [100,150]=50 → 100%
-			name: "single span",
-			trace: buildTraceFromSpans(
-				mkASpan("s1", map[string]string{"service.name": "svc"}, nil, 100, 50),
-			),
-			field: fieldServiceName,
-			want:  map[string]uint64{"svc": 100},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			result := tc.trace.GetSpanAggregation(SpanAggregationExecutionTimePercentage, tc.field)
-			assert.Equal(t, tc.field, result.Field)
-			assert.Equal(t, SpanAggregationExecutionTimePercentage, result.Aggregation)
-			assert.Equal(t, tc.want, result.Value)
-		})
-	}
-}

pkg/types/spantypes/waterfall_span.go

@@ -21,28 +21,13 @@ const (
 // ErrTraceNotFound is returned when a trace ID has no matching spans in ClickHouse.
 var ErrTraceNotFound = errors.NewNotFoundf(errors.CodeNotFound, "trace not found")
 
-// PostableWaterfall is the request body for the v3 waterfall API.
+// PostableWaterfall is the request body for the waterfall API.
 type PostableWaterfall struct {
-	SelectedSpanID   string            `json:"selectedSpanId"`
-	UncollapsedSpans []string          `json:"uncollapsedSpans"`
-	Limit            uint              `json:"limit"`
-	Aggregations     []SpanAggregation `json:"aggregations"`
+	SelectedSpanID   string   `json:"selectedSpanId"`
+	UncollapsedSpans []string `json:"uncollapsedSpans"`
 }
 
 func (p *PostableWaterfall) Validate() error {
-	if len(p.Aggregations) > maxAggregationItems {
-		return ErrTooManyAggregationItems
-	}
-	for _, a := range p.Aggregations {
-		if !a.Aggregation.isValid() {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput, "unknown aggregation type: %q", a.Aggregation)
-		}
-		fc := a.Field.FieldContext
-		if fc != telemetrytypes.FieldContextResource && fc != telemetrytypes.FieldContextAttribute {
-			return errors.NewInvalidInputf(errors.CodeInvalidInput, "aggregation field context must be %q or %q, got %q",
-				telemetrytypes.FieldContextResource, telemetrytypes.FieldContextAttribute, fc)
-		}
-	}
 	return nil
 }
 

pkg/types/spantypes/waterfall_trace.go

@@ -8,7 +8,6 @@ import (
 	"time"
 
 	"github.com/SigNoz/signoz/pkg/types/cachetypes"
-	"github.com/SigNoz/signoz/pkg/types/telemetrytypes"
 )
 
 type TraceSummary struct {
@@ -29,19 +28,18 @@ type WaterfallTrace struct {
 	HasMissingSpans     bool                      `json:"hasMissingSpans"`
 }
 
-// GettableWaterfallTrace is the response for the v3 waterfall API.
+// GettableWaterfallTrace is the response for the waterfall API.
 type GettableWaterfallTrace struct {
-	StartTimestampMillis  uint64                  `json:"startTimestampMillis"`
-	EndTimestampMillis    uint64                  `json:"endTimestampMillis"`
-	RootServiceName       string                  `json:"rootServiceName"`
-	RootServiceEntryPoint string                  `json:"rootServiceEntryPoint"`
-	TotalSpansCount       uint64                  `json:"totalSpansCount"`
-	TotalErrorSpansCount  uint64                  `json:"totalErrorSpansCount"`
-	Spans                 []*WaterfallSpan        `json:"spans"`
-	HasMissingSpans       bool                    `json:"hasMissingSpans"`
-	UncollapsedSpans      []string                `json:"uncollapsedSpans"`
-	HasMore               bool                    `json:"hasMore"`
-	Aggregations          []SpanAggregationResult `json:"aggregations"`
+	StartTimestampMillis  uint64           `json:"startTimestampMillis"`
+	EndTimestampMillis    uint64           `json:"endTimestampMillis"`
+	RootServiceName       string           `json:"rootServiceName"`
+	RootServiceEntryPoint string           `json:"rootServiceEntryPoint"`
+	TotalSpansCount       uint64           `json:"totalSpansCount"`
+	TotalErrorSpansCount  uint64           `json:"totalErrorSpansCount"`
+	Spans                 []*WaterfallSpan `json:"spans"`
+	HasMissingSpans       bool             `json:"hasMissingSpans"`
+	UncollapsedSpans      []string         `json:"uncollapsedSpans"`
+	HasMore               bool             `json:"hasMore"`
 }
 
 // NewWaterfallTrace constructs a WaterfallTrace from processed span data.
@@ -122,23 +120,6 @@ func NewWaterfallTraceFromSpans(nodes []*WaterfallSpan) *WaterfallTrace {
 	)
 }
 
-func (wt *WaterfallTrace) GetWaterfallSpans(uncollapsedSpanIDs []string, selectedSpanID string, limit uint, spanPageSize float64, maxDepthToAutoExpand int) ([]*WaterfallSpan, []string, bool) {
-	// Span selection decision: all spans or windowed
-	selectAllSpans := wt.TotalSpans <= uint64(limit)
-
-	var (
-		selectedSpans    []*WaterfallSpan
-		uncollapsedSpans []string
-	)
-
-	if selectAllSpans {
-		selectedSpans = wt.GetAllSpans()
-	} else {
-		selectedSpans, uncollapsedSpans = wt.GetSelectedSpans(uncollapsedSpanIDs, selectedSpanID, spanPageSize, maxDepthToAutoExpand)
-	}
-	return selectedSpans, uncollapsedSpans, selectAllSpans
-}
-
 // GetAllSpans returns all spans with pre order traversal.
 func (wt *WaterfallTrace) GetAllSpans() []*WaterfallSpan {
 	var preOrderedSpans []*WaterfallSpan
@@ -237,7 +218,6 @@ func NewGettableWaterfallTrace(
 	selectedSpans []*WaterfallSpan,
 	uncollapsedSpans []string,
 	selectAllSpans bool,
-	aggregations []SpanAggregationResult,
 ) *GettableWaterfallTrace {
 	var rootServiceName, rootServiceEntryPoint string
 	if len(traceData.TraceRoots) > 0 {
@@ -250,15 +230,6 @@ func NewGettableWaterfallTrace(
 		span.TimeUnix = span.TimeUnix / 1_000_000
 	}
 
-	// duration values are in nanoseconds; convert in-place to milliseconds.
-	for i := range aggregations {
-		if aggregations[i].Aggregation == SpanAggregationDuration {
-			for k, v := range aggregations[i].Value {
-				aggregations[i].Value[k] = v / 1_000_000
-			}
-		}
-	}
-
 	return &GettableWaterfallTrace{
 		Spans:                 selectedSpans,
 		UncollapsedSpans:      uncollapsedSpans,
@@ -270,7 +241,6 @@ func NewGettableWaterfallTrace(
 		RootServiceEntryPoint: rootServiceEntryPoint,
 		HasMissingSpans:       traceData.HasMissingSpans,
 		HasMore:               !selectAllSpans,
-		Aggregations:          aggregations,
 	}
 }
 
@@ -292,78 +262,3 @@ func windowAroundIndex(selectedIndex, total int, spanLimitPerRequest float64) (s
 	start = max(start, 0)
 	return
 }
-
-// mergeSpanIntervals computes non-overlapping execution time for a set of spans.
-func mergeSpanIntervals(spans []*WaterfallSpan) uint64 {
-	if len(spans) == 0 {
-		return 0
-	}
-	sort.Slice(spans, func(i, j int) bool {
-		return spans[i].TimeUnix < spans[j].TimeUnix
-	})
-
-	currentStart := spans[0].TimeUnix
-	currentEnd := currentStart + spans[0].DurationNano
-	total := uint64(0)
-
-	for _, span := range spans[1:] {
-		startNano := span.TimeUnix
-		endNano := startNano + span.DurationNano
-		if currentEnd >= startNano {
-			if endNano > currentEnd {
-				currentEnd = endNano
-			}
-		} else {
-			total += currentEnd - currentStart
-			currentStart = startNano
-			currentEnd = endNano
-		}
-	}
-	return total + (currentEnd - currentStart)
-}
-
-// GetSpanAggregation computes one aggregation result over all spans in the trace.
-// Duration values are returned in nanoseconds; callers convert to milliseconds as needed.
-func (wt *WaterfallTrace) GetSpanAggregation(aggregation SpanAggregationType, field telemetrytypes.TelemetryFieldKey) SpanAggregationResult {
-	result := SpanAggregationResult{
-		Field:       field,
-		Aggregation: aggregation,
-		Value:       make(map[string]uint64),
-	}
-
-	switch aggregation {
-	case SpanAggregationSpanCount:
-		for _, span := range wt.SpanIDToSpanNodeMap {
-			if key, ok := span.FieldValue(field); ok {
-				result.Value[key]++
-			}
-		}
-
-	case SpanAggregationDuration:
-		spansByField := make(map[string][]*WaterfallSpan)
-		for _, span := range wt.SpanIDToSpanNodeMap {
-			if key, ok := span.FieldValue(field); ok {
-				spansByField[key] = append(spansByField[key], span)
-			}
-		}
-		for key, spans := range spansByField {
-			result.Value[key] = mergeSpanIntervals(spans)
-		}
-
-	case SpanAggregationExecutionTimePercentage:
-		traceDuration := wt.EndTime - wt.StartTime
-		spansByField := make(map[string][]*WaterfallSpan)
-		for _, span := range wt.SpanIDToSpanNodeMap {
-			if key, ok := span.FieldValue(field); ok {
-				spansByField[key] = append(spansByField[key], span)
-			}
-		}
-		if traceDuration > 0 {
-			for key, spans := range spansByField {
-				result.Value[key] = mergeSpanIntervals(spans) * 100 / traceDuration
-			}
-		}
-	}
-
-	return result
-}

tests/integration/testdata/inframonitoring/clusters_filter_dataset.jsonl

@@ -0,0 +1,288 @@
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.node.uid": "web-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-gcp-prod-acc-c1-n1-p-uid", "k8s.pod.name": "web-gcp-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "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": "web-gcp-prod-acc-c1-n1-p-uid", "k8s.pod.name": "web-gcp-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "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": "web-gcp-prod-acc-c1-n1-p-uid", "k8s.pod.name": "web-gcp-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-prod-acc-c1-n1", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.node.uid": "web-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-gcp-prod-acc-c1-n2-p-uid", "k8s.pod.name": "web-gcp-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "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": "web-gcp-prod-acc-c1-n2-p-uid", "k8s.pod.name": "web-gcp-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "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": "web-gcp-prod-acc-c1-n2-p-uid", "k8s.pod.name": "web-gcp-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-prod-acc-c1-n2", "k8s.cluster.name": "web-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.node.uid": "web-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-gcp-dev-acc-c1-n1-p-uid", "k8s.pod.name": "web-gcp-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "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": "web-gcp-dev-acc-c1-n1-p-uid", "k8s.pod.name": "web-gcp-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "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": "web-gcp-dev-acc-c1-n1-p-uid", "k8s.pod.name": "web-gcp-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-dev-acc-c1-n1", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.node.uid": "web-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-gcp-dev-acc-c1-n2-p-uid", "k8s.pod.name": "web-gcp-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "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": "web-gcp-dev-acc-c1-n2-p-uid", "k8s.pod.name": "web-gcp-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "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": "web-gcp-dev-acc-c1-n2-p-uid", "k8s.pod.name": "web-gcp-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-gcp-dev-acc-c1-n2", "k8s.cluster.name": "web-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.node.uid": "api-gcp-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-gcp-prod-acc-c1-n1-p-uid", "k8s.pod.name": "api-gcp-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "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": "api-gcp-prod-acc-c1-n1-p-uid", "k8s.pod.name": "api-gcp-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "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": "api-gcp-prod-acc-c1-n1-p-uid", "k8s.pod.name": "api-gcp-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-prod-acc-c1-n1", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.node.uid": "api-gcp-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-gcp-prod-acc-c1-n2-p-uid", "k8s.pod.name": "api-gcp-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "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": "api-gcp-prod-acc-c1-n2-p-uid", "k8s.pod.name": "api-gcp-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "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": "api-gcp-prod-acc-c1-n2-p-uid", "k8s.pod.name": "api-gcp-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-prod-acc-c1-n2", "k8s.cluster.name": "api-gcp-prod", "cloud.provider": "gcp", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.node.uid": "api-gcp-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-gcp-dev-acc-c1-n1-p-uid", "k8s.pod.name": "api-gcp-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "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": "api-gcp-dev-acc-c1-n1-p-uid", "k8s.pod.name": "api-gcp-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "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": "api-gcp-dev-acc-c1-n1-p-uid", "k8s.pod.name": "api-gcp-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-dev-acc-c1-n1", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.node.uid": "api-gcp-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-gcp-dev-acc-c1-n2-p-uid", "k8s.pod.name": "api-gcp-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "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": "api-gcp-dev-acc-c1-n2-p-uid", "k8s.pod.name": "api-gcp-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "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": "api-gcp-dev-acc-c1-n2-p-uid", "k8s.pod.name": "api-gcp-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-gcp-dev-acc-c1-n2", "k8s.cluster.name": "api-gcp-dev", "cloud.provider": "gcp", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.node.uid": "web-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-aws-prod-acc-c1-n1-p-uid", "k8s.pod.name": "web-aws-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "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": "web-aws-prod-acc-c1-n1-p-uid", "k8s.pod.name": "web-aws-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "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": "web-aws-prod-acc-c1-n1-p-uid", "k8s.pod.name": "web-aws-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-prod-acc-c1-n1", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.node.uid": "web-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-aws-prod-acc-c1-n2-p-uid", "k8s.pod.name": "web-aws-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "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": "web-aws-prod-acc-c1-n2-p-uid", "k8s.pod.name": "web-aws-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "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": "web-aws-prod-acc-c1-n2-p-uid", "k8s.pod.name": "web-aws-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-prod-acc-c1-n2", "k8s.cluster.name": "web-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.node.uid": "web-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-aws-dev-acc-c1-n1-p-uid", "k8s.pod.name": "web-aws-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "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": "web-aws-dev-acc-c1-n1-p-uid", "k8s.pod.name": "web-aws-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "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": "web-aws-dev-acc-c1-n1-p-uid", "k8s.pod.name": "web-aws-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-dev-acc-c1-n1", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.node.uid": "web-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-aws-dev-acc-c1-n2-p-uid", "k8s.pod.name": "web-aws-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "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": "web-aws-dev-acc-c1-n2-p-uid", "k8s.pod.name": "web-aws-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "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": "web-aws-dev-acc-c1-n2-p-uid", "k8s.pod.name": "web-aws-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "web-aws-dev-acc-c1-n2", "k8s.cluster.name": "web-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.node.uid": "api-aws-prod-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-aws-prod-acc-c1-n1-p-uid", "k8s.pod.name": "api-aws-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "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": "api-aws-prod-acc-c1-n1-p-uid", "k8s.pod.name": "api-aws-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "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": "api-aws-prod-acc-c1-n1-p-uid", "k8s.pod.name": "api-aws-prod-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-prod-acc-c1-n1", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.node.uid": "api-aws-prod-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-aws-prod-acc-c1-n2-p-uid", "k8s.pod.name": "api-aws-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "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": "api-aws-prod-acc-c1-n2-p-uid", "k8s.pod.name": "api-aws-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "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": "api-aws-prod-acc-c1-n2-p-uid", "k8s.pod.name": "api-aws-prod-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-prod-acc-c1-n2", "k8s.cluster.name": "api-aws-prod", "cloud.provider": "aws", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.node.uid": "api-aws-dev-acc-c1-n1-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-aws-dev-acc-c1-n1-p-uid", "k8s.pod.name": "api-aws-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "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": "api-aws-dev-acc-c1-n1-p-uid", "k8s.pod.name": "api-aws-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "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": "api-aws-dev-acc-c1-n1-p-uid", "k8s.pod.name": "api-aws-dev-acc-c1-n1-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-dev-acc-c1-n1", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_cpu", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 4.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.memory.working_set", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.allocatable_memory", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 8000000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.node.condition_ready", "labels": {"k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.node.uid": "api-aws-dev-acc-c1-n2-uid", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-aws-dev-acc-c1-n2-p-uid", "k8s.pod.name": "api-aws-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "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": "api-aws-dev-acc-c1-n2-p-uid", "k8s.pod.name": "api-aws-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "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": "api-aws-dev-acc-c1-n2-p-uid", "k8s.pod.name": "api-aws-dev-acc-c1-n2-p", "k8s.namespace.name": "ns-x", "k8s.node.name": "api-aws-dev-acc-c1-n2", "k8s.cluster.name": "api-aws-dev", "cloud.provider": "aws", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}

tests/integration/testdata/inframonitoring/clusters_groupby.jsonl

@@ -0,0 +1,72 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-gcp-1","k8s.node.uid":"node-gb-gcp-1-uid","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-gb-gcp-1-uid","k8s.pod.name":"pod-gb-gcp-1","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-gcp-1","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"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":"pod-gb-gcp-1-uid","k8s.pod.name":"pod-gb-gcp-1","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-gcp-1","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"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":"pod-gb-gcp-1-uid","k8s.pod.name":"pod-gb-gcp-1","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-gcp-1","k8s.cluster.name":"gb-gcp-1","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-gcp-2","k8s.node.uid":"node-gb-gcp-2-uid","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-gb-gcp-2-uid","k8s.pod.name":"pod-gb-gcp-2","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-gcp-2","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"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":"pod-gb-gcp-2-uid","k8s.pod.name":"pod-gb-gcp-2","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-gcp-2","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"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":"pod-gb-gcp-2-uid","k8s.pod.name":"pod-gb-gcp-2","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-gcp-2","k8s.cluster.name":"gb-gcp-2","cloud.provider":"gcp"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-aws-1","k8s.node.uid":"node-gb-aws-1-uid","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-gb-aws-1-uid","k8s.pod.name":"pod-gb-aws-1","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-aws-1","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"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":"pod-gb-aws-1-uid","k8s.pod.name":"pod-gb-aws-1","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-aws-1","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"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":"pod-gb-aws-1-uid","k8s.pod.name":"pod-gb-aws-1","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-aws-1","k8s.cluster.name":"gb-aws-1","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"node-gb-aws-2","k8s.node.uid":"node-gb-aws-2-uid","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-gb-aws-2-uid","k8s.pod.name":"pod-gb-aws-2","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-aws-2","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"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":"pod-gb-aws-2-uid","k8s.pod.name":"pod-gb-aws-2","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-aws-2","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"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":"pod-gb-aws-2-uid","k8s.pod.name":"pod-gb-aws-2","k8s.namespace.name":"ns-x","k8s.node.name":"node-gb-aws-2","k8s.cluster.name":"gb-aws-2","cloud.provider":"aws"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/clusters_missing_metrics.jsonl

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

tests/integration/testdata/inframonitoring/clusters_node_readiness.jsonl

@@ -0,0 +1,78 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-ready-1","k8s.node.uid":"rn-ready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-ready-2","k8s.node.uid":"rn-ready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-ready-3","k8s.node.uid":"rn-ready-3-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-notready-1","k8s.node.uid":"rn-notready-1-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"rn-notready-2","k8s.node.uid":"rn-notready-2-uid","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"rn-pod-uid","k8s.pod.name":"rn-pod","k8s.namespace.name":"ns-x","k8s.node.name":"rn-ready-1","k8s.cluster.name":"rn-cluster"},"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":"rn-pod-uid","k8s.pod.name":"rn-pod","k8s.namespace.name":"ns-x","k8s.node.name":"rn-ready-1","k8s.cluster.name":"rn-cluster"},"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":"rn-pod-uid","k8s.pod.name":"rn-pod","k8s.namespace.name":"ns-x","k8s.node.name":"rn-ready-1","k8s.cluster.name":"rn-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/clusters_orderby.jsonl

@@ -0,0 +1,90 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:00:00+00:00","value":20.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:02:00+00:00","value":20.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":20.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:02:00+00:00","value":50000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":50000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c1-n","k8s.node.uid":"order-c1-n-uid","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"order-c1-p-uid","k8s.pod.name":"order-c1-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c1-n","k8s.cluster.name":"order-c1"},"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":"order-c1-p-uid","k8s.pod.name":"order-c1-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c1-n","k8s.cluster.name":"order-c1"},"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":"order-c1-p-uid","k8s.pod.name":"order-c1-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c1-n","k8s.cluster.name":"order-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:00:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:02:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:00:00+00:00","value":16.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:02:00+00:00","value":16.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":16.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:02:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:00:00+00:00","value":40000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:02:00+00:00","value":40000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":40000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c2-n","k8s.node.uid":"order-c2-n-uid","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"order-c2-p-uid","k8s.pod.name":"order-c2-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c2-n","k8s.cluster.name":"order-c2"},"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":"order-c2-p-uid","k8s.pod.name":"order-c2-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c2-n","k8s.cluster.name":"order-c2"},"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":"order-c2-p-uid","k8s.pod.name":"order-c2-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c2-n","k8s.cluster.name":"order-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:00:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:02:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:00:00+00:00","value":12.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:02:00+00:00","value":12.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":12.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:00:00+00:00","value":3000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:02:00+00:00","value":3000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":3000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:00:00+00:00","value":30000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:02:00+00:00","value":30000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":30000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c3-n","k8s.node.uid":"order-c3-n-uid","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"order-c3-p-uid","k8s.pod.name":"order-c3-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c3-n","k8s.cluster.name":"order-c3"},"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":"order-c3-p-uid","k8s.pod.name":"order-c3-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c3-n","k8s.cluster.name":"order-c3"},"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":"order-c3-p-uid","k8s.pod.name":"order-c3-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c3-n","k8s.cluster.name":"order-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:00:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:02:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:00:00+00:00","value":4000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:02:00+00:00","value":4000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":4000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:00:00+00:00","value":20000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:02:00+00:00","value":20000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":20000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c4-n","k8s.node.uid":"order-c4-n-uid","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"order-c4-p-uid","k8s.pod.name":"order-c4-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c4-n","k8s.cluster.name":"order-c4"},"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":"order-c4-p-uid","k8s.pod.name":"order-c4-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c4-n","k8s.cluster.name":"order-c4"},"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":"order-c4-p-uid","k8s.pod.name":"order-c4-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c4-n","k8s.cluster.name":"order-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:00:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:02:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:00:00+00:00","value":5000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:02:00+00:00","value":5000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":5000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:00:00+00:00","value":10000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:02:00+00:00","value":10000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":10000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-c5-n","k8s.node.uid":"order-c5-n-uid","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"order-c5-p-uid","k8s.pod.name":"order-c5-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c5-n","k8s.cluster.name":"order-c5"},"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":"order-c5-p-uid","k8s.pod.name":"order-c5-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c5-n","k8s.cluster.name":"order-c5"},"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":"order-c5-p-uid","k8s.pod.name":"order-c5-p","k8s.namespace.name":"ns-x","k8s.node.name":"order-c5-n","k8s.cluster.name":"order-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/clusters_pagination.jsonl

@@ -0,0 +1,126 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:00:00+00:00","value":7.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:02:00+00:00","value":7.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":7.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c1-n","k8s.node.uid":"page-c1-n-uid","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-c1-p-uid","k8s.pod.name":"page-c1-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c1-n","k8s.cluster.name":"page-c1"},"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":"page-c1-p-uid","k8s.pod.name":"page-c1-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c1-n","k8s.cluster.name":"page-c1"},"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":"page-c1-p-uid","k8s.pod.name":"page-c1-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c1-n","k8s.cluster.name":"page-c1"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:00:00+00:00","value":6.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:02:00+00:00","value":6.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":6.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c2-n","k8s.node.uid":"page-c2-n-uid","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-c2-p-uid","k8s.pod.name":"page-c2-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c2-n","k8s.cluster.name":"page-c2"},"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":"page-c2-p-uid","k8s.pod.name":"page-c2-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c2-n","k8s.cluster.name":"page-c2"},"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":"page-c2-p-uid","k8s.pod.name":"page-c2-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c2-n","k8s.cluster.name":"page-c2"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:00:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:02:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c3-n","k8s.node.uid":"page-c3-n-uid","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-c3-p-uid","k8s.pod.name":"page-c3-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c3-n","k8s.cluster.name":"page-c3"},"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":"page-c3-p-uid","k8s.pod.name":"page-c3-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c3-n","k8s.cluster.name":"page-c3"},"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":"page-c3-p-uid","k8s.pod.name":"page-c3-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c3-n","k8s.cluster.name":"page-c3"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c4-n","k8s.node.uid":"page-c4-n-uid","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-c4-p-uid","k8s.pod.name":"page-c4-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c4-n","k8s.cluster.name":"page-c4"},"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":"page-c4-p-uid","k8s.pod.name":"page-c4-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c4-n","k8s.cluster.name":"page-c4"},"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":"page-c4-p-uid","k8s.pod.name":"page-c4-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c4-n","k8s.cluster.name":"page-c4"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:00:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:02:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c5-n","k8s.node.uid":"page-c5-n-uid","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-c5-p-uid","k8s.pod.name":"page-c5-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c5-n","k8s.cluster.name":"page-c5"},"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":"page-c5-p-uid","k8s.pod.name":"page-c5-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c5-n","k8s.cluster.name":"page-c5"},"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":"page-c5-p-uid","k8s.pod.name":"page-c5-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c5-n","k8s.cluster.name":"page-c5"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:00:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:02:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:04:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c6-n","k8s.node.uid":"page-c6-n-uid","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-c6-p-uid","k8s.pod.name":"page-c6-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c6-n","k8s.cluster.name":"page-c6"},"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":"page-c6-p-uid","k8s.pod.name":"page-c6-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c6-n","k8s.cluster.name":"page-c6"},"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":"page-c6-p-uid","k8s.pod.name":"page-c6-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c6-n","k8s.cluster.name":"page-c6"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-c7-n","k8s.node.uid":"page-c7-n-uid","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-c7-p-uid","k8s.pod.name":"page-c7-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c7-n","k8s.cluster.name":"page-c7"},"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":"page-c7-p-uid","k8s.pod.name":"page-c7-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c7-n","k8s.cluster.name":"page-c7"},"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":"page-c7-p-uid","k8s.pod.name":"page-c7-p","k8s.namespace.name":"ns-x","k8s.node.name":"page-c7-n","k8s.cluster.name":"page-c7"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/clusters_pod_phases.jsonl

@@ -0,0 +1,36 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"pp-node","k8s.node.uid":"pp-node-uid","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-run-1-uid","k8s.pod.name":"pp-run-1","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"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":"pp-run-1-uid","k8s.pod.name":"pp-run-1","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"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":"pp-run-1-uid","k8s.pod.name":"pp-run-1","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-run-2-uid","k8s.pod.name":"pp-run-2","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"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":"pp-run-2-uid","k8s.pod.name":"pp-run-2","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"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":"pp-run-2-uid","k8s.pod.name":"pp-run-2","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-run-3-uid","k8s.pod.name":"pp-run-3","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"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":"pp-run-3-uid","k8s.pod.name":"pp-run-3","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"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":"pp-run-3-uid","k8s.pod.name":"pp-run-3","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-run-4-uid","k8s.pod.name":"pp-run-4","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"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":"pp-run-4-uid","k8s.pod.name":"pp-run-4","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"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":"pp-run-4-uid","k8s.pod.name":"pp-run-4","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-pend-1-uid","k8s.pod.name":"pp-pend-1","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-pend-1-uid","k8s.pod.name":"pp-pend-1","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-pend-1-uid","k8s.pod.name":"pp-pend-1","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-fail-1-uid","k8s.pod.name":"pp-fail-1","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-fail-1-uid","k8s.pod.name":"pp-fail-1","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-fail-1-uid","k8s.pod.name":"pp-fail-1","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-fail-2-uid","k8s.pod.name":"pp-fail-2","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:00:00+00:00","value":4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-fail-2-uid","k8s.pod.name":"pp-fail-2","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:02:00+00:00","value":4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pp-fail-2-uid","k8s.pod.name":"pp-fail-2","k8s.namespace.name":"ns-x","k8s.node.name":"pp-node","k8s.cluster.name":"pp-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/clusters_value_accuracy.jsonl

@@ -0,0 +1,90 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c1-n1","k8s.node.uid":"acc-c1-n1-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-c1-n1-p-uid","k8s.pod.name":"acc-c1-n1-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c1-n1","k8s.cluster.name":"acc-cluster-1"},"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":"acc-c1-n1-p-uid","k8s.pod.name":"acc-c1-n1-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c1-n1","k8s.cluster.name":"acc-cluster-1"},"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":"acc-c1-n1-p-uid","k8s.pod.name":"acc-c1-n1-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c1-n1","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:00:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:02:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":8000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c1-n2","k8s.node.uid":"acc-c1-n2-uid","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-c1-n2-p-uid","k8s.pod.name":"acc-c1-n2-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c1-n2","k8s.cluster.name":"acc-cluster-1"},"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":"acc-c1-n2-p-uid","k8s.pod.name":"acc-c1-n2-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c1-n2","k8s.cluster.name":"acc-cluster-1"},"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":"acc-c1-n2-p-uid","k8s.pod.name":"acc-c1-n2-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c1-n2","k8s.cluster.name":"acc-cluster-1"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":16000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":16000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":16000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c2-n1","k8s.node.uid":"acc-c2-n1-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-c2-n1-p-uid","k8s.pod.name":"acc-c2-n1-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c2-n1","k8s.cluster.name":"acc-cluster-2"},"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":"acc-c2-n1-p-uid","k8s.pod.name":"acc-c2-n1-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c2-n1","k8s.cluster.name":"acc-cluster-2"},"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":"acc-c2-n1-p-uid","k8s.pod.name":"acc-c2-n1-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c2-n1","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":16000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":16000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":16000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c2-n2","k8s.node.uid":"acc-c2-n2-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-c2-n2-p-uid","k8s.pod.name":"acc-c2-n2-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c2-n2","k8s.cluster.name":"acc-cluster-2"},"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":"acc-c2-n2-p-uid","k8s.pod.name":"acc-c2-n2-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c2-n2","k8s.cluster.name":"acc-cluster-2"},"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":"acc-c2-n2-p-uid","k8s.pod.name":"acc-c2-n2-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c2-n2","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":8.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.memory.working_set","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":16000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":16000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":16000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-c2-n3","k8s.node.uid":"acc-c2-n3-uid","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-c2-n3-p-uid","k8s.pod.name":"acc-c2-n3-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c2-n3","k8s.cluster.name":"acc-cluster-2"},"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":"acc-c2-n3-p-uid","k8s.pod.name":"acc-c2-n3-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c2-n3","k8s.cluster.name":"acc-cluster-2"},"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":"acc-c2-n3-p-uid","k8s.pod.name":"acc-c2-n3-p","k8s.namespace.name":"ns-x","k8s.node.name":"acc-c2-n3","k8s.cluster.name":"acc-cluster-2"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/clusters_value_accuracy_expected.json

@@ -0,0 +1,40 @@
+{
+  "records": [
+    {
+      "clusterName": "acc-cluster-1",
+      "clusterCPU": 1.0,
+      "clusterCPUAllocatable": 8.0,
+      "clusterMemory": 2000000000.0,
+      "clusterMemoryAllocatable": 16000000000.0,
+      "nodeCountsByReadiness": {
+        "ready": 2,
+        "notReady": 0
+      },
+      "podCountsByPhase": {
+        "pending": 0,
+        "running": 2,
+        "succeeded": 0,
+        "failed": 0,
+        "unknown": 0
+      }
+    },
+    {
+      "clusterName": "acc-cluster-2",
+      "clusterCPU": 3.0,
+      "clusterCPUAllocatable": 24.0,
+      "clusterMemory": 6000000000.0,
+      "clusterMemoryAllocatable": 48000000000.0,
+      "nodeCountsByReadiness": {
+        "ready": 3,
+        "notReady": 0
+      },
+      "podCountsByPhase": {
+        "pending": 0,
+        "running": 3,
+        "succeeded": 0,
+        "failed": 0,
+        "unknown": 0
+      }
+    }
+  ]
+}

tests/integration/tests/inframonitoring/05_clusters.py

@@ -0,0 +1,634 @@
+"""Integration tests for v2 infra-monitoring cluster endpoints."""
+
+import json
+from datetime import UTC, datetime, timedelta
+from http import HTTPStatus
+
+import pytest
+import requests
+
+from fixtures import types
+from fixtures.auth import USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD
+from fixtures.fs import get_testdata_file_path
+from fixtures.metrics import Metrics
+from fixtures.querier import compare_values
+
+ENDPOINT = "/api/v2/infra_monitoring/clusters"
+
+# Required metrics for the v2 clusters endpoint
+# (pkg/modules/inframonitoring/implinframonitoring/clusters_constants.go:23-30).
+REQUIRED_METRICS = {
+    "k8s.node.cpu.usage",
+    "k8s.node.allocatable_cpu",
+    "k8s.node.memory.working_set",
+    "k8s.node.allocatable_memory",
+    "k8s.node.condition_ready",
+    "k8s.pod.phase",
+}
+
+
+def test_clusters_accuracy(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Assert response shape/contract + exact per-cluster metric sums + node
+    readiness + pod phase counts.
+
+    SpaceAggregationSum across nodes per cluster (clusters_constants.go:62,82,100,119).
+    acc-cluster-1: 2 nodes @ cpu=0.5, alloc_cpu=4, mem=1e9, alloc_mem=8e9
+        -> clusterCPU=1.0, clusterCPUAllocatable=8.0, clusterMemory=2e9, clusterMemoryAllocatable=16e9
+    acc-cluster-2: 3 nodes @ cpu=1.0, alloc_cpu=8, mem=2e9, alloc_mem=16e9
+        -> clusterCPU=3.0, clusterCPUAllocatable=24.0, clusterMemory=6e9, clusterMemoryAllocatable=48e9
+    """
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/clusters_value_accuracy.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    with open(
+        get_testdata_file_path("inframonitoring/clusters_value_accuracy_expected.json"),
+        encoding="utf-8",
+    ) as f:
+        expected = json.load(f)
+    exp_by_name = {r["clusterName"]: r for r in expected["records"]}
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(ENDPOINT),
+        headers={"authorization": f"Bearer {token}"},
+        json={
+            "start": int((now - timedelta(minutes=5)).timestamp() * 1000),
+            "end": int(now.timestamp() * 1000),
+            "limit": 50,
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+
+    # Shape/contract.
+    assert data["total"] == len(expected["records"])
+    assert len(data["records"]) == len(expected["records"])
+    assert data["requiredMetricsCheck"]["missingMetrics"] == []
+    assert data["endTimeBeforeRetention"] is False
+    assert {r["clusterName"] for r in data["records"]} == set(exp_by_name.keys())
+
+    for record in data["records"]:
+        for field in (
+            "clusterName",
+            "clusterCPU",
+            "clusterCPUAllocatable",
+            "clusterMemory",
+            "clusterMemoryAllocatable",
+            "nodeCountsByReadiness",
+            "podCountsByPhase",
+            "meta",
+        ):
+            assert field in record, f"missing {field} in {record!r}"
+
+        for bucket in ("ready", "notReady"):
+            assert bucket in record["nodeCountsByReadiness"]
+            assert isinstance(record["nodeCountsByReadiness"][bucket], int)
+        for bucket in ("pending", "running", "succeeded", "failed", "unknown"):
+            assert bucket in record["podCountsByPhase"]
+            assert isinstance(record["podCountsByPhase"][bucket], int)
+
+        assert record["meta"].get("k8s.cluster.name") == record["clusterName"]
+
+        # Exact values.
+        exp = exp_by_name[record["clusterName"]]
+        for field in (
+            "clusterCPU",
+            "clusterCPUAllocatable",
+            "clusterMemory",
+            "clusterMemoryAllocatable",
+        ):
+            assert compare_values(record[field], exp[field], 1e-6), f"{record['clusterName']}.{field}: got {record[field]}, expected {exp[field]}"
+        assert record["nodeCountsByReadiness"] == exp["nodeCountsByReadiness"]
+        assert record["podCountsByPhase"] == exp["podCountsByPhase"]
+
+
+def test_clusters_missing_metrics(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Seed only k8s.node.cpu.usage; assert other 5 required metrics flagged missing."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/clusters_missing_metrics.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(ENDPOINT),
+        headers={"authorization": f"Bearer {token}"},
+        json={
+            "start": int((now - timedelta(minutes=5)).timestamp() * 1000),
+            "end": int(now.timestamp() * 1000),
+            "limit": 50,
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+
+    assert set(data["requiredMetricsCheck"]["missingMetrics"]) == (REQUIRED_METRICS - {"k8s.node.cpu.usage"})
+    assert data["records"] == []
+    assert data["total"] == 0
+
+
+@pytest.mark.parametrize(
+    "expression,expected",
+    [
+        pytest.param(
+            "cloud.provider = 'gcp' AND env = 'prod'",
+            {"web-gcp-prod", "api-gcp-prod"},
+            id="and",
+        ),
+        pytest.param(
+            "k8s.cluster.name IN ('web-gcp-prod', 'api-aws-dev')",
+            {"web-gcp-prod", "api-aws-dev"},
+            id="in",
+        ),
+        # NOT IN on the partition key returns the rest. NOT IN on a
+        # non-partition label (e.g. cloud.provider) is unreliable — likely a
+        # QB v5 label-extraction gap; covered indirectly via the and_not_in combo.
+        pytest.param(
+            "k8s.cluster.name NOT IN ('web-gcp-prod', 'web-gcp-dev', 'api-gcp-prod', 'api-gcp-dev')",
+            {"web-aws-prod", "web-aws-dev", "api-aws-prod", "api-aws-dev"},
+            id="not_in",
+        ),
+        pytest.param(
+            "k8s.cluster.name CONTAINS 'web'",
+            {"web-gcp-prod", "web-gcp-dev", "web-aws-prod", "web-aws-dev"},
+            id="contains",
+        ),
+        pytest.param(
+            "cloud.provider = 'gcp' AND k8s.cluster.name IN ('web-gcp-prod', 'api-gcp-prod')",
+            {"web-gcp-prod", "api-gcp-prod"},
+            id="and_in",
+        ),
+        pytest.param(
+            "cloud.provider = 'gcp' AND k8s.cluster.name NOT IN ('web-gcp-prod', 'web-gcp-dev')",
+            {"api-gcp-prod", "api-gcp-dev"},
+            id="and_not_in",
+        ),
+        pytest.param(
+            "env = 'prod' AND k8s.cluster.name CONTAINS 'web'",
+            {"web-gcp-prod", "web-aws-prod"},
+            id="and_contains",
+        ),
+        pytest.param(
+            "k8s.cluster.name IN ('web-gcp-prod', 'web-aws-prod', 'api-gcp-prod') AND k8s.cluster.name CONTAINS 'web'",
+            {"web-gcp-prod", "web-aws-prod"},
+            id="in_contains",
+        ),
+    ],
+)
+def test_clusters_filter(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    expression: str,
+    expected: set,
+) -> None:
+    """Filter operators (=, IN, NOT IN, CONTAINS) and their AND-combinations
+    return exactly the matching clusters, with undistorted per-cluster metric
+    values."""
+    # Every cluster in clusters_filter_dataset.jsonl carries the same sample
+    # pattern as acc-cluster-1 in clusters_value_accuracy.jsonl (2 nodes), so
+    # all filtered records must resolve to these exact values (mirrors
+    # clusters_value_accuracy_expected.json acc-cluster-1).
+    expected_values = {
+        "clusterCPU": 1.0,
+        "clusterCPUAllocatable": 8.0,
+        "clusterMemory": 2000000000.0,
+        "clusterMemoryAllocatable": 16000000000.0,
+    }
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/clusters_filter_dataset.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(ENDPOINT),
+        headers={"authorization": f"Bearer {token}"},
+        json={
+            "start": int((now - timedelta(minutes=5)).timestamp() * 1000),
+            "end": int(now.timestamp() * 1000),
+            "limit": 50,
+            "filter": {"expression": expression},
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert {r["clusterName"] for r in data["records"]} == expected
+    assert data["total"] == len(expected)
+
+    # Filtering must not distort per-cluster aggregation values.
+    for record in data["records"]:
+        for field in expected_values:
+            assert compare_values(record[field], expected_values[field], 1e-6), f"{record['clusterName']}.{field}: got {record[field]}, expected {expected_values[field]}"
+
+
+@pytest.mark.parametrize(
+    "expression,err_substr",
+    [
+        pytest.param("k8s.cluster.namee = 'web-gcp-prod'", "k8s.cluster.namee", id="bad_attr_name"),
+        pytest.param("k8s.cluster.name =", None, id="trailing_op"),
+        pytest.param("(k8s.cluster.name = 'web-gcp-prod'", None, id="unclosed_paren"),
+    ],
+)
+def test_clusters_filter_invalid(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    expression: str,
+    err_substr,
+) -> None:
+    """Invalid filter expressions (typo'd attribute key, malformed grammar) return
+    400 invalid_input with structured errors; bad attribute keys are named in them."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/clusters_filter_dataset.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(ENDPOINT),
+        headers={"authorization": f"Bearer {token}"},
+        json={
+            "start": int((now - timedelta(minutes=5)).timestamp() * 1000),
+            "end": int(now.timestamp() * 1000),
+            "limit": 50,
+            "filter": {"expression": expression},
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.BAD_REQUEST, f"expected 400, got {response.status_code}: {response.text}"
+    body = response.json()
+    assert body["status"] == "error"
+    assert body["error"]["code"] == "invalid_input"
+    assert len(body["error"]["errors"]) > 0
+    if err_substr is not None:
+        assert any(err_substr in e["message"] for e in body["error"]["errors"]), f"{err_substr!r} not surfaced: {body['error']['errors']!r}"
+
+
+def test_clusters_node_readiness_aggregation(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Cluster with mixed node readiness: 3 ready + 2 not_ready -> {ready:3, notReady:2}."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/clusters_node_readiness.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(ENDPOINT),
+        headers={"authorization": f"Bearer {token}"},
+        json={
+            "start": int((now - timedelta(minutes=5)).timestamp() * 1000),
+            "end": int(now.timestamp() * 1000),
+            "limit": 50,
+            "filter": {"expression": "k8s.cluster.name = 'rn-cluster'"},
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 1
+    rec = data["records"][0]
+    assert rec["clusterName"] == "rn-cluster"
+    assert rec["nodeCountsByReadiness"] == {"ready": 3, "notReady": 2}
+
+
+def test_clusters_pod_phase_aggregation(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Cluster with mixed pod phases: 4 running + 1 pending + 2 failed."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/clusters_pod_phases.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(ENDPOINT),
+        headers={"authorization": f"Bearer {token}"},
+        json={
+            "start": int((now - timedelta(minutes=5)).timestamp() * 1000),
+            "end": int(now.timestamp() * 1000),
+            "limit": 50,
+            "filter": {"expression": "k8s.cluster.name = 'pp-cluster'"},
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 1
+    rec = data["records"][0]
+    assert rec["clusterName"] == "pp-cluster"
+    assert rec["podCountsByPhase"] == {
+        "pending": 1,
+        "running": 4,
+        "succeeded": 0,
+        "failed": 2,
+        "unknown": 0,
+    }
+
+
+@pytest.mark.parametrize(
+    "group_key,expected",
+    [
+        # groupBy=[k8s.cluster.name]: one record per cluster, clusterName
+        # populated (clusters.go:29-32). Each cluster has 1 ready node, 1 pod.
+        pytest.param(
+            "k8s.cluster.name",
+            {
+                "gb-gcp-1": {"readiness": {"ready": 1, "notReady": 0}, "running": 1},
+                "gb-gcp-2": {"readiness": {"ready": 1, "notReady": 0}, "running": 1},
+                "gb-aws-1": {"readiness": {"ready": 1, "notReady": 0}, "running": 1},
+                "gb-aws-2": {"readiness": {"ready": 1, "notReady": 0}, "running": 1},
+            },
+            id="cluster_name",
+        ),
+        # groupBy=[cloud.provider]: aggregated across each provider's 2 clusters,
+        # clusterName empty (custom-groupBy branch).
+        pytest.param(
+            "cloud.provider",
+            {
+                "gcp": {"readiness": {"ready": 2, "notReady": 0}, "running": 2},
+                "aws": {"readiness": {"ready": 2, "notReady": 0}, "running": 2},
+            },
+            id="cloud_provider",
+        ),
+    ],
+)
+def test_clusters_groupby(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    group_key: str,
+    expected: dict,
+) -> None:
+    """groupBy returns one record per distinct group with aggregated readiness
+    and pod-phase counts. clusterName is populated only when grouping by
+    k8s.cluster.name (clusters.go:29-32 list-vs-grouped branch); meta surfaces
+    the groupBy key."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/clusters_groupby.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(ENDPOINT),
+        headers={"authorization": f"Bearer {token}"},
+        json={
+            "start": int((now - timedelta(minutes=5)).timestamp() * 1000),
+            "end": int(now.timestamp() * 1000),
+            "limit": 50,
+            "groupBy": [
+                {
+                    "name": group_key,
+                    "fieldDataType": "string",
+                    "fieldContext": "resource",
+                }
+            ],
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == len(expected)
+
+    group_of = lambda r: r["clusterName"] if group_key == "k8s.cluster.name" else r["meta"][group_key]  # noqa: E731  # pylint: disable=unnecessary-lambda-assignment
+    by_group = {group_of(r): r for r in data["records"]}
+    assert set(by_group.keys()) == set(expected.keys())
+
+    for group, exp in expected.items():
+        rec = by_group[group]
+        # clusterName populated per cluster when grouping by k8s.cluster.name,
+        # empty otherwise.
+        assert rec["clusterName"] == (group if group_key == "k8s.cluster.name" else "")
+        assert rec["nodeCountsByReadiness"] == exp["readiness"]
+        assert rec["podCountsByPhase"]["running"] == exp["running"]
+        for other in ("pending", "succeeded", "failed", "unknown"):
+            assert rec["podCountsByPhase"][other] == 0
+        assert group_key in rec["meta"], rec["meta"]
+
+
+def test_clusters_pagination(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Pagination: per-page len matches min(limit, total-offset), total invariant,
+    pages cover the full set with no overlap. The final offset is beyond total:
+    it returns empty records while total still reflects dataset size."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/clusters_pagination.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    K, limit = 7, 3
+    seen_names: list[str] = []
+    seen_totals: set[int] = set()
+
+    for offset in (0, 3, 6, K + 5):
+        response = requests.post(
+            signoz.self.host_configs["8080"].get(ENDPOINT),
+            headers={"authorization": f"Bearer {token}"},
+            json={
+                "start": int((now - timedelta(minutes=5)).timestamp() * 1000),
+                "end": int(now.timestamp() * 1000),
+                "limit": limit,
+                "offset": offset,
+                "filter": {"expression": "k8s.cluster.name CONTAINS 'page-'"},
+            },
+            timeout=5,
+        )
+        assert response.status_code == HTTPStatus.OK, response.text
+        data = response.json()["data"]
+        seen_totals.add(data["total"])
+        expected_len = max(0, min(limit, K - offset))
+        assert len(data["records"]) == expected_len, f"offset={offset}: expected {expected_len}, got {len(data['records'])}"
+        seen_names.extend(r["clusterName"] for r in data["records"])
+
+    assert seen_totals == {K}
+    assert len(seen_names) == K
+    assert set(seen_names) == {f"page-c{i}" for i in range(1, K + 1)}
+
+
+# orderBy keys per clusters_constants.go (cpu, cpu_allocatable, memory,
+# memory_allocatable). k8s.cluster.name sorts via the metadata-name branch
+# (PaginateMetadataByName) and is only allowed when groupBy is empty.
+@pytest.mark.parametrize(
+    "column,record_field",
+    [
+        pytest.param("cpu", "clusterCPU", id="cpu"),
+        pytest.param("cpu_allocatable", "clusterCPUAllocatable", id="cpu_allocatable"),
+        pytest.param("memory", "clusterMemory", id="memory"),
+        pytest.param("memory_allocatable", "clusterMemoryAllocatable", id="memory_allocatable"),
+        pytest.param("k8s.cluster.name", "clusterName", id="cluster_name"),
+    ],
+)
+@pytest.mark.parametrize("direction", ["asc", "desc"])
+def test_clusters_orderby(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    column: str,
+    record_field: str,
+    direction: str,
+) -> None:
+    """Every orderBy column x direction: total/len stay K (invariant under
+    sort) and records come back sorted by the requested column."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/clusters_orderby.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    K = 5
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(ENDPOINT),
+        headers={"authorization": f"Bearer {token}"},
+        json={
+            "start": int((now - timedelta(minutes=5)).timestamp() * 1000),
+            "end": int(now.timestamp() * 1000),
+            "limit": 50,
+            "orderBy": {"key": {"name": column}, "direction": direction},
+            # Guards against clusters seeded by other tests in the shared backend.
+            "filter": {"expression": "k8s.cluster.name CONTAINS 'order-'"},
+        },
+        timeout=5,
+    )
+    ctx = f"orderBy={column} {direction}"
+    assert response.status_code == HTTPStatus.OK, f"{ctx}: {response.text}"
+    data = response.json()["data"]
+    assert data["total"] == K, f"{ctx}: total={data['total']}"
+    assert len(data["records"]) == K, f"{ctx}: len(records)={len(data['records'])}"
+
+    values = [r[record_field] for r in data["records"]]
+    expected = sorted(values, reverse=(direction == "desc"))
+    assert values == expected, f"{ctx} not sorted; got {values}"
+
+
+@pytest.mark.parametrize(
+    "payload_override,err_substr",
+    [
+        pytest.param({"start": 0}, "start must be greater than 0", id="start_zero"),
+        pytest.param({"start": -1}, "start must be greater than 0", id="start_negative"),
+        pytest.param({"end": 0}, "end must be greater than 0", id="end_zero"),
+        pytest.param({"end": -1}, "end must be greater than 0", id="end_negative"),
+        pytest.param({"_use_end_eq_start": True}, "must be less than end", id="start_equals_end"),
+        pytest.param({"_use_start_gt_end": True}, "must be less than end", id="start_greater_than_end"),
+        pytest.param({"limit": 0}, "limit must be between", id="limit_zero"),
+        pytest.param({"limit": 5001}, "limit must be between", id="limit_too_large"),
+        pytest.param({"offset": -1}, "offset cannot be negative", id="offset_negative"),
+        pytest.param(
+            {"orderBy": {"key": {"name": "bogus_col"}, "direction": "desc"}},
+            "invalid order by key",
+            id="orderby_invalid_key",
+        ),
+        pytest.param(
+            {"orderBy": {"key": {"name": "cpu"}, "direction": "up"}},
+            "invalid order by direction",
+            id="orderby_invalid_direction",
+        ),
+        pytest.param(
+            {
+                "orderBy": {"key": {"name": "k8s.cluster.name"}, "direction": "desc"},
+                "groupBy": [
+                    {
+                        "name": "cloud.provider",
+                        "fieldDataType": "string",
+                        "fieldContext": "resource",
+                    }
+                ],
+            },
+            "is only allowed when groupBy is empty",
+            id="orderby_clustername_with_groupby",
+        ),
+    ],
+)
+def test_clusters_validation_errors(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    payload_override: dict,
+    err_substr: str,
+) -> None:
+    """All PostableClusters.Validate() rules reject with 400 + descriptive error.
+    See pkg/types/inframonitoringtypes/clusters.go:45-97."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    body: dict = {
+        "start": int((now - timedelta(minutes=5)).timestamp() * 1000),
+        "end": int(now.timestamp() * 1000),
+        "limit": 50,
+    }
+    if payload_override.pop("_use_end_eq_start", False):
+        body["end"] = body["start"]
+    if payload_override.pop("_use_start_gt_end", False):
+        body["start"] = body["end"] + 1
+    body.update(payload_override)
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(ENDPOINT),
+        headers={"authorization": f"Bearer {token}"},
+        json=body,
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.BAD_REQUEST, response.text
+    error = response.json()["error"]
+    assert error["code"] == "invalid_input"
+    assert err_substr.lower() in error["message"].lower(), f"expected substring {err_substr!r} not found in: {error['message']!r}"