feat(infra-monitoring): assert metric value accuracy in namespaces filter tests

- regenerate namespaces_filter_dataset.jsonl so every namespace mirrors the
  acc-ns-1 sample pattern (2 pods) from namespaces_value_accuracy.jsonl
- test_namespaces_filter now asserts namespaceCPU/namespaceMemory per record

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.github/workflows/integrationci.yaml

@@ -43,6 +43,7 @@ jobs:
           - cloudintegrations
           - dashboard
           - ingestionkeys
+          - inframonitoring
           - logspipelines
           - passwordauthn
           - preference

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

@@ -6,6 +6,10 @@ import { EllipsisVertical } from '@signozhq/icons';
 import type { DashboardtypesPanelDTO } from 'api/generated/services/sigNoz.schemas';
 import cx from 'classnames';
 
+import type { DashboardSection } from '../../utils';
+import type { DeletePanelArgs } from './hooks/useDeletePanel';
+import type { MovePanelArgs } from './hooks/useMovePanelToSection';
+import PanelActionsMenu from './PanelActionsMenu/PanelActionsMenu';
 import styles from './Panel.module.scss';
 
 interface Props {
@@ -17,9 +21,22 @@ interface Props {
 	 * data. Currently unused on purpose.
 	 */
 	isVisible?: boolean;
+	/** Section actions — present only in editable sectioned mode. */
+	currentLayoutIndex?: number;
+	sections?: DashboardSection[];
+	onMovePanel?: (args: MovePanelArgs) => void;
+	onDeletePanel?: (args: DeletePanelArgs) => void;
 }
 
-function Panel({ panel, panelId, isVisible }: Props): JSX.Element {
+function Panel({
+	panel,
+	panelId,
+	isVisible,
+	currentLayoutIndex,
+	sections,
+	onMovePanel,
+	onDeletePanel,
+}: Props): JSX.Element {
 	const name = panel?.spec?.display?.name || `Panel ${panelId.slice(0, 6)}`;
 	const description = panel?.spec?.display?.description;
 	const kind = panel?.spec?.plugin?.kind?.replace(/^signoz\//, '') ?? 'unknown';
@@ -48,7 +65,17 @@ function Panel({ panel, panelId, isVisible }: Props): JSX.Element {
 					</Typography.Text>
 					<Badge className={styles.badge}>{kind}</Badge>
 				</div>
-				<EllipsisVertical size={14} />
+				{currentLayoutIndex !== undefined && (onMovePanel || onDeletePanel) ? (
+					<PanelActionsMenu
+						panelId={panelId}
+						currentLayoutIndex={currentLayoutIndex}
+						sections={sections ?? []}
+						onMovePanel={onMovePanel}
+						onDeletePanel={onDeletePanel}
+					/>
+				) : (
+					<EllipsisVertical size={14} />
+				)}
 			</div>
 
 			<div className={styles.body}>

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelActionsMenu/PanelActionsMenu.module.scss

@@ -0,0 +1,16 @@
+.trigger {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	padding: 2px;
+	background: transparent;
+	border: none;
+	border-radius: 2px;
+	color: var(--bg-vanilla-400, #8993ae);
+	cursor: pointer;
+
+	&:hover {
+		color: var(--bg-vanilla-100, #fff);
+		background: var(--bg-slate-400, #1d212d);
+	}
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelActionsMenu/PanelActionsMenu.tsx

@@ -0,0 +1,95 @@
+import { useMemo } from 'react';
+import { EllipsisVertical, FolderInput, Trash2 } from '@signozhq/icons';
+import { DropdownMenuSimple } from '@signozhq/ui/dropdown-menu';
+import type { MenuItem } from '@signozhq/ui/dropdown-menu';
+
+import type { DashboardSection } from '../../../utils';
+import type { DeletePanelArgs } from '../hooks/useDeletePanel';
+import type { MovePanelArgs } from '../hooks/useMovePanelToSection';
+import styles from './PanelActionsMenu.module.scss';
+
+interface Props {
+	panelId: string;
+	currentLayoutIndex: number;
+	sections: DashboardSection[];
+	onMovePanel?: (args: MovePanelArgs) => void;
+	onDeletePanel?: (args: DeletePanelArgs) => void;
+}
+
+function PanelActionsMenu({
+	panelId,
+	currentLayoutIndex,
+	sections,
+	onMovePanel,
+	onDeletePanel,
+}: Props): JSX.Element {
+	const items = useMemo<MenuItem[]>(() => {
+		const result: MenuItem[] = [];
+
+		if (onMovePanel) {
+			const targets = sections.filter(
+				(s) => s.title && s.layoutIndex !== currentLayoutIndex,
+			);
+			if (targets.length === 0) {
+				result.push({
+					key: 'move',
+					label: 'Move to section',
+					icon: <FolderInput size={14} />,
+					disabled: true,
+				});
+			} else {
+				result.push({
+					key: 'move',
+					label: 'Move to section',
+					icon: <FolderInput size={14} />,
+					children: targets.map((s) => ({
+						key: `move-${s.layoutIndex}`,
+						label: s.title,
+						onClick: (): void =>
+							onMovePanel({
+								panelId,
+								fromLayoutIndex: currentLayoutIndex,
+								toLayoutIndex: s.layoutIndex,
+							}),
+					})),
+				});
+			}
+		}
+
+		if (onDeletePanel) {
+			if (result.length > 0) {
+				result.push({ type: 'divider' });
+			}
+			result.push({
+				key: 'delete-panel',
+				danger: true,
+				icon: <Trash2 size={14} />,
+				label: 'Delete panel',
+				onClick: (): void =>
+					onDeletePanel({ panelId, layoutIndex: currentLayoutIndex }),
+			});
+		}
+
+		return result;
+	}, [sections, currentLayoutIndex, panelId, onMovePanel, onDeletePanel]);
+
+	return (
+		<DropdownMenuSimple menu={{ items }}>
+			<button
+				type="button"
+				className={styles.trigger}
+				aria-label="Panel actions"
+				data-testid={`panel-actions-${panelId}`}
+				// Stop pointer/mouse down from reaching the RGL drag handle this
+				// button lives inside, so opening the menu never starts a panel drag.
+				onPointerDown={(e): void => e.stopPropagation()}
+				onMouseDown={(e): void => e.stopPropagation()}
+				onClick={(e): void => e.stopPropagation()}
+			>
+				<EllipsisVertical size={14} />
+			</button>
+		</DropdownMenuSimple>
+	);
+}
+
+export default PanelActionsMenu;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeSelectionModal.module.scss

@@ -0,0 +1,22 @@
+.grid {
+	display: grid;
+	grid-template-columns: repeat(2, 1fr);
+	gap: 8px;
+}
+
+.typeButton {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	padding: 12px;
+	background: var(--bg-ink-400, #0b0c0e);
+	border: 1px solid var(--bg-slate-400, #1d212d);
+	border-radius: 4px;
+	color: var(--bg-vanilla-100, #fff);
+	cursor: pointer;
+	text-align: left;
+
+	&:hover {
+		border-color: var(--bg-robin-500);
+	}
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/PanelTypeSelectionModal/PanelTypeSelectionModal.tsx

@@ -0,0 +1,82 @@
+import { Modal } from 'antd';
+import {
+	BarChart,
+	ChartLine,
+	ChartPie,
+	Hash,
+	List,
+	Table,
+} from '@signozhq/icons';
+
+import styles from './PanelTypeSelectionModal.module.scss';
+
+interface PanelType {
+	pluginKind: string;
+	label: string;
+	icon: JSX.Element;
+}
+
+const PANEL_TYPES: PanelType[] = [
+	{
+		pluginKind: 'signoz/TimeSeriesPanel',
+		label: 'Time Series',
+		icon: <ChartLine size={16} />,
+	},
+	{ pluginKind: 'signoz/NumberPanel', label: 'Value', icon: <Hash size={16} /> },
+	{ pluginKind: 'signoz/TablePanel', label: 'Table', icon: <Table size={16} /> },
+	{
+		pluginKind: 'signoz/BarChartPanel',
+		label: 'Bar Chart',
+		icon: <BarChart size={16} />,
+	},
+	{
+		pluginKind: 'signoz/PieChartPanel',
+		label: 'Pie Chart',
+		icon: <ChartPie size={16} />,
+	},
+	{
+		pluginKind: 'signoz/HistogramPanel',
+		label: 'Histogram',
+		icon: <BarChart size={16} />,
+	},
+	{ pluginKind: 'signoz/ListPanel', label: 'List', icon: <List size={16} /> },
+];
+
+interface Props {
+	open: boolean;
+	onClose: () => void;
+	onSelect: (pluginKind: string) => void;
+}
+
+function PanelTypeSelectionModal({
+	open,
+	onClose,
+	onSelect,
+}: Props): JSX.Element {
+	return (
+		<Modal
+			open={open}
+			title="Select a panel type"
+			onCancel={onClose}
+			footer={null}
+			destroyOnClose
+		>
+			<div className={styles.grid}>
+				{PANEL_TYPES.map((type) => (
+					<button
+						key={type.pluginKind}
+						type="button"
+						className={styles.typeButton}
+						data-testid={`panel-type-${type.pluginKind}`}
+						onClick={(): void => onSelect(type.pluginKind)}
+					>
+						{type.icon}
+						{type.label}
+					</button>
+				))}
+			</div>
+		</Modal>
+	);
+}
+
+export default PanelTypeSelectionModal;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useAddPanelToSection.ts

@@ -0,0 +1,76 @@
+import { useCallback } from 'react';
+import { v4 as uuid } from 'uuid';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import {
+	addPanelToSectionOps,
+	createDefaultPanel,
+	panelRef,
+} from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+interface Params {
+	sections: DashboardSection[];
+}
+
+export interface AddPanelArgs {
+	layoutIndex: number;
+	pluginKind: string;
+}
+
+/**
+ * Creates a new panel and places its item ref at the bottom of the target
+ * section, as one atomic patch. Structure-only: the panel is a valid minimal
+ * placeholder (its query is filled in once the panel editor lands).
+ */
+export function useAddPanelToSection({
+	sections,
+}: Params): (args: AddPanelArgs) => Promise<void> {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const { showErrorModal } = useErrorModal();
+
+	return useCallback(
+		async ({ layoutIndex, pluginKind }: AddPanelArgs): Promise<void> => {
+			if (!dashboardId) {
+				return;
+			}
+			const target = sections.find((s) => s.layoutIndex === layoutIndex);
+			if (!target) {
+				return;
+			}
+
+			const panelId = uuid();
+			const nextY = target.items.reduce(
+				(max, i) => Math.max(max, i.y + i.height),
+				0,
+			);
+
+			try {
+				await patchDashboardV2(
+					{ id: dashboardId },
+					addPanelToSectionOps({
+						panelId,
+						panel: createDefaultPanel(pluginKind),
+						layoutIndex,
+						item: {
+							x: 0,
+							y: nextY,
+							width: 6,
+							height: 6,
+							content: { $ref: panelRef(panelId) },
+						},
+					}),
+				);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			}
+		},
+		[sections, dashboardId, refetch, showErrorModal],
+	);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useDeletePanel.ts

@@ -0,0 +1,54 @@
+import { useCallback } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { removePanelOp, replaceSectionItemsOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+interface Params {
+	sections: DashboardSection[];
+}
+
+export interface DeletePanelArgs {
+	panelId: string;
+	layoutIndex: number;
+}
+
+/**
+ * Removes a panel: drops its item ref from the section's items and deletes the
+ * panel from `spec.panels`, as one atomic patch.
+ */
+export function useDeletePanel({
+	sections,
+}: Params): (args: DeletePanelArgs) => Promise<void> {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const { showErrorModal } = useErrorModal();
+
+	return useCallback(
+		async ({ panelId, layoutIndex }: DeletePanelArgs): Promise<void> => {
+			if (!dashboardId) {
+				return;
+			}
+			const section = sections.find((s) => s.layoutIndex === layoutIndex);
+			if (!section) {
+				return;
+			}
+
+			const nextItems = section.items.filter((i) => i.id !== panelId);
+			try {
+				await patchDashboardV2({ id: dashboardId }, [
+					replaceSectionItemsOp(layoutIndex, nextItems),
+					removePanelOp(panelId),
+				]);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			}
+		},
+		[sections, dashboardId, refetch, showErrorModal],
+	);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Panel/hooks/useMovePanelToSection.ts

@@ -0,0 +1,79 @@
+import { useCallback } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { movePanelBetweenSectionsOps } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+export interface MovePanelArgs {
+	panelId: string;
+	fromLayoutIndex: number;
+	toLayoutIndex: number;
+}
+
+interface Params {
+	sections: DashboardSection[];
+}
+
+/**
+ * Relocates a panel's item ref from one section to another. The panel itself
+ * stays in `spec.panels`; only the grid item moves, dropped into a free row at
+ * the bottom of the target section. Persisted as one atomic patch.
+ */
+export function useMovePanelToSection({
+	sections,
+}: Params): (args: MovePanelArgs) => Promise<void> {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const { showErrorModal } = useErrorModal();
+
+	return useCallback(
+		async ({
+			panelId,
+			fromLayoutIndex,
+			toLayoutIndex,
+		}: MovePanelArgs): Promise<void> => {
+			if (!dashboardId || fromLayoutIndex === toLayoutIndex) {
+				return;
+			}
+
+			const source = sections.find((s) => s.layoutIndex === fromLayoutIndex);
+			const target = sections.find((s) => s.layoutIndex === toLayoutIndex);
+			if (!source || !target) {
+				return;
+			}
+
+			const moved = source.items.find((i) => i.id === panelId);
+			if (!moved) {
+				return;
+			}
+
+			const sourceItems = source.items.filter((i) => i.id !== panelId);
+			// Place at a fresh row at the bottom of the target section.
+			const nextY = target.items.reduce(
+				(max, i) => Math.max(max, i.y + i.height),
+				0,
+			);
+			const targetItems = [...target.items, { ...moved, x: 0, y: nextY }];
+
+			try {
+				await patchDashboardV2(
+					{ id: dashboardId },
+					movePanelBetweenSectionsOps({
+						sourceIndex: fromLayoutIndex,
+						sourceItems,
+						targetIndex: toLayoutIndex,
+						targetItems,
+					}),
+				);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			}
+		},
+		[sections, dashboardId, refetch, showErrorModal],
+	);
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/AddSectionControl/AddSectionControl.module.scss

@@ -0,0 +1,17 @@
+.addButton {
+	display: inline-flex;
+	align-items: center;
+	gap: 6px;
+	margin-top: 8px;
+	padding: 8px 12px;
+	background: transparent;
+	border: 1px dashed var(--bg-slate-400, #1d212d);
+	border-radius: 4px;
+	color: var(--bg-vanilla-400, #8993ae);
+	cursor: pointer;
+
+	&:hover {
+		border-color: var(--bg-robin-500);
+		color: var(--bg-vanilla-100, #fff);
+	}
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/AddSectionControl/AddSectionControl.tsx

@@ -0,0 +1,67 @@
+import { useState } from 'react';
+import { Plus } from '@signozhq/icons';
+import type { DashboardtypesLayoutDTO } from 'api/generated/services/sigNoz.schemas';
+
+import type { DashboardSection } from '../../../utils';
+import { useAddSection } from '../hooks/useAddSection';
+import { useFirstSectionMigration } from '../hooks/useFirstSectionMigration';
+import FirstSectionMigrationModal from '../FirstSectionMigrationModal';
+import styles from './AddSectionControl.module.scss';
+
+const DEFAULT_SECTION_TITLE = 'New section';
+
+interface Props {
+	sections: DashboardSection[];
+	layouts: DashboardtypesLayoutDTO[] | undefined | null;
+	isSectioned: boolean;
+}
+
+function AddSectionControl({
+	sections,
+	layouts,
+	isSectioned,
+}: Props): JSX.Element {
+	const [isMigrationOpen, setIsMigrationOpen] = useState(false);
+	const { addSection } = useAddSection({ layouts });
+	const { migrate, isSaving } = useFirstSectionMigration({ sections });
+
+	// Free-flowing dashboard with existing panels → must migrate before sections
+	// can coexist (every panel must belong to a section once any exists).
+	const needsMigration =
+		!isSectioned && sections.some((s) => s.items.length > 0);
+
+	const handleClick = (): void => {
+		if (needsMigration) {
+			setIsMigrationOpen(true);
+			return;
+		}
+		void addSection(DEFAULT_SECTION_TITLE);
+	};
+
+	const handleConfirmMigration = async (): Promise<void> => {
+		await migrate(DEFAULT_SECTION_TITLE);
+		setIsMigrationOpen(false);
+	};
+
+	return (
+		<>
+			<button
+				type="button"
+				className={styles.addButton}
+				onClick={handleClick}
+				data-testid="add-section"
+			>
+				<Plus size={14} />
+				Add section
+			</button>
+			<FirstSectionMigrationModal
+				open={isMigrationOpen}
+				isSaving={isSaving}
+				onClose={(): void => setIsMigrationOpen(false)}
+				onConfirm={handleConfirmMigration}
+			/>
+		</>
+	);
+}
+
+export default AddSectionControl;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/FirstSectionMigrationModal.tsx

@@ -0,0 +1,41 @@
+import { Modal } from 'antd';
+import { Typography } from '@signozhq/ui/typography';
+
+interface Props {
+	open: boolean;
+	isSaving: boolean;
+	onClose: () => void;
+	onConfirm: () => void;
+}
+
+/**
+ * Shown when the user adds the first section to a free-flowing dashboard that
+ * already has panels. Confirms grouping the existing panels into a section
+ * before proceeding.
+ */
+function FirstSectionMigrationModal({
+	open,
+	isSaving,
+	onClose,
+	onConfirm,
+}: Props): JSX.Element {
+	return (
+		<Modal
+			open={open}
+			title="Group panels into sections?"
+			onCancel={onClose}
+			onOk={onConfirm}
+			okText="Continue"
+			okButtonProps={{ disabled: isSaving, 'data-testid': 'confirm-migration' }}
+			destroyOnClose
+		>
+			<Typography.Text>
+				This dashboard&apos;s panels are currently free-flowing. Adding a section
+				will move the existing panels into their own section, and a new empty
+				section will be added below. You can rename sections afterwards.
+			</Typography.Text>
+		</Modal>
+	);
+}
+
+export default FirstSectionMigrationModal;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/RenameSectionModal.tsx

@@ -0,0 +1,64 @@
+import { useEffect, useState } from 'react';
+import { Modal } from 'antd';
+import { Input } from '@signozhq/ui/input';
+
+interface Props {
+	open: boolean;
+	initialValue: string;
+	isSaving: boolean;
+	onClose: () => void;
+	onSubmit: (title: string) => void;
+}
+
+function RenameSectionModal({
+	open,
+	initialValue,
+	isSaving,
+	onClose,
+	onSubmit,
+}: Props): JSX.Element {
+	const [value, setValue] = useState<string>(initialValue);
+
+	// Reseed the field each time the modal opens.
+	useEffect(() => {
+		if (open) {
+			setValue(initialValue);
+		}
+	}, [open, initialValue]);
+
+	const submit = (): void => {
+		const trimmed = value.trim();
+		if (trimmed) {
+			onSubmit(trimmed);
+		}
+	};
+
+	return (
+		<Modal
+			open={open}
+			title="Rename section"
+			onCancel={onClose}
+			onOk={submit}
+			okText="Rename"
+			okButtonProps={{ disabled: isSaving || !value.trim() }}
+			destroyOnClose
+		>
+			<Input
+				testId="rename-section-input"
+				autoFocus
+				value={value}
+				maxLength={120}
+				placeholder="Section name"
+				onChange={(e): void => setValue(e.target.value)}
+				onKeyDown={(e): void => {
+					if (e.key === 'Enter') {
+						e.preventDefault();
+						submit();
+					}
+				}}
+			/>
+		</Modal>
+	);
+}
+
+export default RenameSectionModal;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/Section/Section.tsx

@@ -1,17 +1,45 @@
 import { useRef, useState } from 'react';
+import { Modal } from 'antd';
 
 import { useIntersectionObserver } from 'hooks/useIntersectionObserver';
 
 import type { DashboardSection } from '../../../utils';
+import type { AddPanelArgs } from '../../Panel/hooks/useAddPanelToSection';
+import type { DeletePanelArgs } from '../../Panel/hooks/useDeletePanel';
+import type { MovePanelArgs } from '../../Panel/hooks/useMovePanelToSection';
+import PanelTypeSelectionModal from '../../Panel/PanelTypeSelectionModal/PanelTypeSelectionModal';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import { useDeleteSection } from '../hooks/useDeleteSection';
+import { useRenameSection } from '../hooks/useRenameSection';
+import { useToggleSectionCollapse } from '../hooks/useToggleSectionCollapse';
+import RenameSectionModal from '../RenameSectionModal';
 import SectionGrid from '../SectionGrid/SectionGrid';
-import SectionHeader from '../SectionHeader/SectionHeader';
+import SectionHeader, {
+	type SectionDragHandle,
+} from '../SectionHeader/SectionHeader';
 import styles from './Section.module.scss';
 
 interface Props {
 	section: DashboardSection;
+	/** Adds a panel to this section; present only in editable sectioned mode. */
+	onAddPanel?: (args: AddPanelArgs) => void;
+	/** All sections + per-panel handlers, for the panel "Move to section" / delete actions. */
+	sections?: DashboardSection[];
+	onMovePanel?: (args: MovePanelArgs) => void;
+	onDeletePanel?: (args: DeletePanelArgs) => void;
+	/** Provided by SortableSection in sectioned mode; absent for untitled/free-flow. */
+	dragHandle?: SectionDragHandle;
 }
 
-function Section({ section }: Props): JSX.Element {
+function Section({
+	section,
+	onAddPanel,
+	sections,
+	onMovePanel,
+	onDeletePanel,
+	dragHandle,
+}: Props): JSX.Element {
+	const isEditable = useDashboardStore((s) => s.isEditable);
 	const containerRef = useRef<HTMLDivElement>(null);
 	// Placeholder signal for lazy panel query-loading (consumed in a later PR):
 	// true once the section scrolls into (or near) the viewport.
@@ -19,10 +47,48 @@ function Section({ section }: Props): JSX.Element {
 		rootMargin: '200px',
 	});
 
-	const [open, setOpen] = useState<boolean>(section.open);
-	const toggle = (): void => setOpen((prev) => !prev);
+	const { open, toggle } = useToggleSectionCollapse({ sectionId: section.id });
 
-	const grid = <SectionGrid items={section.items} isVisible={isVisible} />;
+	const [isRenaming, setIsRenaming] = useState(false);
+	const { rename, isSaving } = useRenameSection({
+		layoutIndex: section.layoutIndex,
+	});
+
+	const handleRenameSubmit = async (title: string): Promise<void> => {
+		const ok = await rename(title);
+		if (ok) {
+			setIsRenaming(false);
+		}
+	};
+
+	const [isAddingPanel, setIsAddingPanel] = useState(false);
+	const handleSelectPanelType = (pluginKind: string): void => {
+		onAddPanel?.({ layoutIndex: section.layoutIndex, pluginKind });
+		setIsAddingPanel(false);
+	};
+
+	const { deleteSection } = useDeleteSection({ section });
+	const confirmDeleteSection = (): void => {
+		Modal.confirm({
+			title: `Delete section "${section.title ?? ''}"?`,
+			content: 'Panels in this section will be removed.',
+			okText: 'Delete',
+			okButtonProps: { danger: true },
+			centered: true,
+			onOk: () => deleteSection(),
+		});
+	};
+
+	const grid = (
+		<SectionGrid
+			items={section.items}
+			layoutIndex={section.layoutIndex}
+			isVisible={isVisible}
+			sections={sections}
+			onMovePanel={onMovePanel}
+			onDeletePanel={onDeletePanel}
+		/>
+	);
 
 	if (!section.title) {
 		// Untitled section — just the grid (no header chrome), but still observed
@@ -51,8 +117,26 @@ function Section({ section }: Props): JSX.Element {
 				open={open}
 				onToggle={toggle}
 				repeatVariable={section.repeatVariable}
+				dragHandle={dragHandle}
+				onRename={isEditable ? (): void => setIsRenaming(true) : undefined}
+				onAddPanel={
+					isEditable && onAddPanel ? (): void => setIsAddingPanel(true) : undefined
+				}
+				onDeleteSection={isEditable ? confirmDeleteSection : undefined}
 			/>
 			{open ? grid : null}
+			<RenameSectionModal
+				open={isRenaming}
+				initialValue={section.title}
+				isSaving={isSaving}
+				onClose={(): void => setIsRenaming(false)}
+				onSubmit={handleRenameSubmit}
+			/>
+			<PanelTypeSelectionModal
+				open={isAddingPanel}
+				onClose={(): void => setIsAddingPanel(false)}
+				onSelect={handleSelectPanelType}
+			/>
 		</div>
 	);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionActionsMenu/SectionActionsMenu.module.scss

@@ -0,0 +1,16 @@
+.trigger {
+	display: inline-flex;
+	align-items: center;
+	justify-content: center;
+	padding: 2px;
+	background: transparent;
+	border: none;
+	border-radius: 2px;
+	color: var(--bg-vanilla-400, #8993ae);
+	cursor: pointer;
+
+	&:hover {
+		color: var(--bg-vanilla-100, #fff);
+		background: var(--bg-slate-400, #1d212d);
+	}
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionActionsMenu/SectionActionsMenu.tsx

@@ -0,0 +1,68 @@
+import { useMemo } from 'react';
+import { EllipsisVertical, PenLine, Plus, Trash2 } from '@signozhq/icons';
+import { DropdownMenuSimple } from '@signozhq/ui/dropdown-menu';
+import type { MenuItem } from '@signozhq/ui/dropdown-menu';
+
+import styles from './SectionActionsMenu.module.scss';
+
+interface Props {
+	sectionId: string;
+	onAddPanel?: () => void;
+	onRename?: () => void;
+	onDeleteSection?: () => void;
+}
+
+function SectionActionsMenu({
+	sectionId,
+	onAddPanel,
+	onRename,
+	onDeleteSection,
+}: Props): JSX.Element {
+	const items = useMemo<MenuItem[]>(() => {
+		const result: MenuItem[] = [];
+		if (onAddPanel) {
+			result.push({
+				key: 'add-panel',
+				icon: <Plus size={14} />,
+				label: 'Add panel',
+				onClick: onAddPanel,
+			});
+		}
+		if (onRename) {
+			result.push({
+				key: 'rename',
+				icon: <PenLine size={14} />,
+				label: 'Rename section',
+				onClick: onRename,
+			});
+		}
+		if (onDeleteSection) {
+			result.push(
+				{ type: 'divider' },
+				{
+					key: 'delete-section',
+					danger: true,
+					icon: <Trash2 size={14} />,
+					label: 'Delete section',
+					onClick: onDeleteSection,
+				},
+			);
+		}
+		return result;
+	}, [onAddPanel, onRename, onDeleteSection]);
+
+	return (
+		<DropdownMenuSimple menu={{ items }}>
+			<button
+				type="button"
+				className={styles.trigger}
+				aria-label="Section actions"
+				data-testid={`dashboard-section-actions-${sectionId}`}
+			>
+				<EllipsisVertical size={14} />
+			</button>
+		</DropdownMenuSimple>
+	);
+}
+
+export default SectionActionsMenu;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionDragPreview/SectionDragPreview.module.scss

@@ -0,0 +1,7 @@
+.preview {
+	border: 1px solid var(--bg-robin-500);
+	border-radius: 4px;
+	background: var(--bg-ink-400, #0b0c0e);
+	box-shadow: 0 8px 24px rgb(0 0 0 / 40%);
+	cursor: grabbing;
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionDragPreview/SectionDragPreview.tsx

@@ -0,0 +1,32 @@
+import type { DashboardSection } from '../../../utils';
+import SectionHeader from '../SectionHeader/SectionHeader';
+import styles from './SectionDragPreview.module.scss';
+
+interface Props {
+	section: DashboardSection;
+}
+
+/**
+ * Lightweight preview rendered inside the DragOverlay while a section is being
+ * dragged. Deliberately header-only (no react-grid-layout) so the overlay is
+ * cheap and never triggers RGL width re-measurement.
+ */
+function SectionDragPreview({ section }: Props): JSX.Element {
+	const panelCount = section.items.length;
+	const title = `${section.title ?? ''} · ${panelCount} ${
+		panelCount === 1 ? 'panel' : 'panels'
+	}`;
+
+	return (
+		<div className={styles.preview}>
+			<SectionHeader
+				sectionId={`${section.id}-preview`}
+				title={title}
+				open={false}
+				onToggle={(): void => undefined}
+			/>
+		</div>
+	);
+}
+
+export default SectionDragPreview;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionGrid/SectionGrid.tsx

@@ -2,18 +2,35 @@ import { useMemo } from 'react';
 import GridLayout, { WidthProvider, type Layout } from 'react-grid-layout';
 
 import type { DashboardSection } from '../../../utils';
+import type { DeletePanelArgs } from '../../Panel/hooks/useDeletePanel';
+import type { MovePanelArgs } from '../../Panel/hooks/useMovePanelToSection';
 import Panel from '../../Panel/Panel';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import { usePersistLayout } from '../hooks/usePersistLayout';
 import styles from './SectionGrid.module.scss';
 
 const ResponsiveGridLayout = WidthProvider(GridLayout);
 
 interface Props {
 	items: DashboardSection['items'];
+	layoutIndex: number;
 	/** Forwarded to panels — true when the parent section is in the viewport. */
 	isVisible?: boolean;
+	/** All sections + handlers — present only in editable sectioned mode (panel "Move to section" / delete). */
+	sections?: DashboardSection[];
+	onMovePanel?: (args: MovePanelArgs) => void;
+	onDeletePanel?: (args: DeletePanelArgs) => void;
 }
 
-function SectionGrid({ items, isVisible }: Props): JSX.Element {
+function SectionGrid({
+	items,
+	layoutIndex,
+	isVisible,
+	sections,
+	onMovePanel,
+	onDeletePanel,
+}: Props): JSX.Element {
+	const isEditable = useDashboardStore((s) => s.isEditable);
 	const rglLayout = useMemo<Layout[]>(
 		() =>
 			items.map((item) => ({
@@ -26,6 +43,8 @@ function SectionGrid({ items, isVisible }: Props): JSX.Element {
 		[items],
 	);
 
+	const { handleLayoutChange } = usePersistLayout({ layoutIndex, items });
+
 	return (
 		<ResponsiveGridLayout
 			className={styles.grid}
@@ -34,13 +53,24 @@ function SectionGrid({ items, isVisible }: Props): JSX.Element {
 			autoSize
 			useCSSTransforms
 			layout={rglLayout}
-			isDraggable={false}
-			isResizable={false}
+			draggableHandle=".panel-drag-handle"
+			isDraggable={isEditable}
+			isResizable={isEditable}
+			onDragStop={handleLayoutChange}
+			onResizeStop={handleLayoutChange}
 			margin={[8, 8]}
 		>
 			{items.map((item) => (
 				<div key={item.id}>
-					<Panel panel={item.panel} panelId={item.id} isVisible={isVisible} />
+					<Panel
+						panel={item.panel}
+						panelId={item.id}
+						isVisible={isVisible}
+						currentLayoutIndex={layoutIndex}
+						sections={isEditable ? sections : undefined}
+						onMovePanel={isEditable ? onMovePanel : undefined}
+						onDeletePanel={isEditable ? onDeletePanel : undefined}
+					/>
 				</div>
 			))}
 		</ResponsiveGridLayout>

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionHeader/SectionHeader.tsx

@@ -1,15 +1,29 @@
-import { ChevronDown, ChevronRight } from '@signozhq/icons';
+import type { DraggableAttributes } from '@dnd-kit/core';
+import type { SyntheticListenerMap } from '@dnd-kit/core/dist/hooks/utilities';
+import { ChevronDown, ChevronRight, GripVertical } from '@signozhq/icons';
 import { Typography } from '@signozhq/ui/typography';
 import cx from 'classnames';
 
+import SectionActionsMenu from '../SectionActionsMenu/SectionActionsMenu';
 import styles from './SectionHeader.module.scss';
 
+export interface SectionDragHandle {
+	attributes: DraggableAttributes;
+	listeners: SyntheticListenerMap | undefined;
+	setActivatorNodeRef: (element: HTMLElement | null) => void;
+}
+
 interface Props {
 	sectionId: string;
 	title: string;
 	open: boolean;
 	onToggle: () => void;
 	repeatVariable?: string;
+	/** Provided by SortableSection in sectioned mode; absent for untitled/free-flow. */
+	dragHandle?: SectionDragHandle;
+	onRename?: () => void;
+	onAddPanel?: () => void;
+	onDeleteSection?: () => void;
 }
 
 function SectionHeader({
@@ -18,9 +32,27 @@ function SectionHeader({
 	open,
 	onToggle,
 	repeatVariable,
+	dragHandle,
+	onRename,
+	onAddPanel,
+	onDeleteSection,
 }: Props): JSX.Element {
+	const hasActions = !!(onAddPanel || onRename || onDeleteSection);
 	return (
 		<div className={cx(styles.header, { [styles.headerOpen]: open })}>
+			{dragHandle ? (
+				<button
+					type="button"
+					className={styles.dragHandle}
+					ref={dragHandle.setActivatorNodeRef}
+					aria-label="Drag to reorder section"
+					data-testid={`dashboard-section-drag-${sectionId}`}
+					{...dragHandle.attributes}
+					{...dragHandle.listeners}
+				>
+					<GripVertical size={14} />
+				</button>
+			) : null}
 			<button
 				type="button"
 				className={styles.toggle}
@@ -35,6 +67,14 @@ function SectionHeader({
 					</Typography.Text>
 				) : null}
 			</button>
+			{hasActions ? (
+				<SectionActionsMenu
+					sectionId={sectionId}
+					onAddPanel={onAddPanel}
+					onRename={onRename}
+					onDeleteSection={onDeleteSection}
+				/>
+			) : null}
 		</div>
 	);
 }

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SectionList.tsx

@@ -0,0 +1,102 @@
+import { useMemo } from 'react';
+import { closestCenter, DndContext, DragOverlay } from '@dnd-kit/core';
+import {
+	restrictToParentElement,
+	restrictToVerticalAxis,
+} from '@dnd-kit/modifiers';
+import {
+	SortableContext,
+	verticalListSortingStrategy,
+} from '@dnd-kit/sortable';
+import type { DashboardtypesLayoutDTO } from 'api/generated/services/sigNoz.schemas';
+
+import type { DashboardSection } from '../../utils';
+import { useAddPanelToSection } from '../Panel/hooks/useAddPanelToSection';
+import { useDeletePanel } from '../Panel/hooks/useDeletePanel';
+import { useMovePanelToSection } from '../Panel/hooks/useMovePanelToSection';
+import { useDashboardStore } from '../../store/useDashboardStore';
+import { useSectionDragReorder } from './hooks/useSectionDragReorder';
+import Section from './Section/Section';
+import SectionDragPreview from './SectionDragPreview/SectionDragPreview';
+import SortableSection from './SortableSection';
+
+interface Props {
+	sections: DashboardSection[];
+	layouts: DashboardtypesLayoutDTO[] | undefined | null;
+}
+
+function SectionList({ sections, layouts }: Props): JSX.Element {
+	const isEditable = useDashboardStore((s) => s.isEditable);
+
+	const {
+		sensors,
+		orderedSections,
+		activeSection,
+		onDragStart,
+		onDragEnd,
+		onDragCancel,
+	} = useSectionDragReorder({ sections, layouts });
+
+	const onAddPanel = useAddPanelToSection({ sections });
+	const onMovePanel = useMovePanelToSection({ sections });
+	const onDeletePanel = useDeletePanel({ sections });
+
+	// Only titled sections participate in reordering; untitled (free-flow)
+	// blocks render in place without a drag handle.
+	const sortableIds = useMemo(
+		() => orderedSections.filter((s) => s.title).map((s) => s.id),
+		[orderedSections],
+	);
+
+	if (!isEditable) {
+		return (
+			<>
+				{sections.map((section) => (
+					<Section key={section.id} section={section} />
+				))}
+			</>
+		);
+	}
+
+	return (
+		<DndContext
+			sensors={sensors}
+			collisionDetection={closestCenter}
+			modifiers={[restrictToVerticalAxis, restrictToParentElement]}
+			onDragStart={onDragStart}
+			onDragEnd={onDragEnd}
+			onDragCancel={onDragCancel}
+		>
+			<SortableContext items={sortableIds} strategy={verticalListSortingStrategy}>
+				{orderedSections.map((section) =>
+					section.title ? (
+						<SortableSection
+							key={section.id}
+							section={section}
+							sections={sections}
+							onAddPanel={onAddPanel}
+							onMovePanel={onMovePanel}
+							onDeletePanel={onDeletePanel}
+						/>
+					) : (
+						<Section
+							key={section.id}
+							section={section}
+							sections={sections}
+							onAddPanel={onAddPanel}
+							onMovePanel={onMovePanel}
+							onDeletePanel={onDeletePanel}
+						/>
+					),
+				)}
+			</SortableContext>
+			{/* dropAnimation disabled: optimistic reorder already places the section,
+			    so animating the overlay back would cause a visible snap/shake. */}
+			<DragOverlay dropAnimation={null}>
+				{activeSection ? <SectionDragPreview section={activeSection} /> : null}
+			</DragOverlay>
+		</DndContext>
+	);
+}
+
+export default SectionList;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/SortableSection.tsx

@@ -0,0 +1,59 @@
+import { useSortable } from '@dnd-kit/sortable';
+import { CSS } from '@dnd-kit/utilities';
+
+import type { DashboardSection } from '../../utils';
+import type { AddPanelArgs } from '../Panel/hooks/useAddPanelToSection';
+import type { DeletePanelArgs } from '../Panel/hooks/useDeletePanel';
+import type { MovePanelArgs } from '../Panel/hooks/useMovePanelToSection';
+import Section from './Section/Section';
+
+interface Props {
+	section: DashboardSection;
+	sections: DashboardSection[];
+	onAddPanel: (args: AddPanelArgs) => void;
+	onMovePanel: (args: MovePanelArgs) => void;
+	onDeletePanel: (args: DeletePanelArgs) => void;
+}
+
+function SortableSection({
+	section,
+	sections,
+	onAddPanel,
+	onMovePanel,
+	onDeletePanel,
+}: Props): JSX.Element {
+	const {
+		attributes,
+		listeners,
+		setNodeRef,
+		setActivatorNodeRef,
+		transform,
+		transition,
+		isDragging,
+	} = useSortable({ id: section.id });
+
+	// dnd-kit drives the drag transform per-frame, so this must be an inline
+	// style — there is no static-stylesheet equivalent for a live transform.
+	// While dragging, the original is hidden (the DragOverlay renders the moving
+	// preview); keeping it in place preserves the gap and lets siblings animate.
+	const style: React.CSSProperties = {
+		transform: CSS.Transform.toString(transform),
+		transition,
+		opacity: isDragging ? 0 : undefined,
+	};
+
+	return (
+		<div ref={setNodeRef} style={style}>
+			<Section
+				section={section}
+				sections={sections}
+				onAddPanel={onAddPanel}
+				onMovePanel={onMovePanel}
+				onDeletePanel={onDeletePanel}
+				dragHandle={{ attributes, listeners, setActivatorNodeRef }}
+			/>
+		</div>
+	);
+}
+
+export default SortableSection;

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useAddSection.ts

@@ -0,0 +1,59 @@
+import { useCallback, useState } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import type { DashboardtypesLayoutDTO } from 'api/generated/services/sigNoz.schemas';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import {
+	addSectionOp,
+	newGridLayout,
+	reorderLayoutsOp,
+} from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+
+interface Params {
+	layouts: DashboardtypesLayoutDTO[] | undefined | null;
+}
+
+interface Result {
+	addSection: (title: string) => Promise<void>;
+	isSaving: boolean;
+}
+
+/**
+ * Appends an empty titled section. When the dashboard has no layouts yet, the
+ * layouts array is created via a `replace` (an `add` to a missing/empty array
+ * pointer is unreliable); otherwise a new Grid is appended.
+ */
+export function useAddSection({ layouts }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [isSaving, setIsSaving] = useState(false);
+	const { showErrorModal } = useErrorModal();
+
+	const addSection = useCallback(
+		async (title: string): Promise<void> => {
+			const trimmed = title.trim();
+			if (!dashboardId || !trimmed) {
+				return;
+			}
+			const op =
+				!layouts || layouts.length === 0
+					? reorderLayoutsOp([newGridLayout(trimmed)])
+					: addSectionOp(trimmed);
+			try {
+				setIsSaving(true);
+				await patchDashboardV2({ id: dashboardId }, [op]);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			} finally {
+				setIsSaving(false);
+			}
+		},
+		[layouts, dashboardId, refetch, showErrorModal],
+	);
+
+	return { addSection, isSaving };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useDeleteSection.ts

@@ -0,0 +1,51 @@
+import { useCallback, useState } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import type { DashboardtypesJSONPatchOperationDTO } from 'api/generated/services/sigNoz.schemas';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { removePanelOp, removeSectionOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+interface Params {
+	section: DashboardSection;
+}
+
+interface Result {
+	deleteSection: () => Promise<void>;
+	isSaving: boolean;
+}
+
+/**
+ * Deletes a section: removes its Grid layout and deletes every panel it
+ * contained from `spec.panels` (orphan cleanup), as one atomic patch.
+ */
+export function useDeleteSection({ section }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [isSaving, setIsSaving] = useState(false);
+	const { showErrorModal } = useErrorModal();
+
+	const deleteSection = useCallback(async (): Promise<void> => {
+		if (!dashboardId) {
+			return;
+		}
+		const ops: DashboardtypesJSONPatchOperationDTO[] = section.items.map((i) =>
+			removePanelOp(i.id),
+		);
+		ops.push(removeSectionOp(section.layoutIndex));
+		try {
+			setIsSaving(true);
+			await patchDashboardV2({ id: dashboardId }, ops);
+			refetch();
+		} catch (error) {
+			showErrorModal(error as APIError);
+		} finally {
+			setIsSaving(false);
+		}
+	}, [section, dashboardId, refetch, showErrorModal]);
+
+	return { deleteSection, isSaving };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useFirstSectionMigration.ts

@@ -0,0 +1,64 @@
+import { useCallback, useState } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import type { DashboardtypesJSONPatchOperationDTO } from 'api/generated/services/sigNoz.schemas';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { addSectionOp, titleUntitledSectionOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+interface Params {
+	sections: DashboardSection[];
+}
+
+interface Result {
+	migrate: (newSectionTitle: string) => Promise<void>;
+	isSaving: boolean;
+}
+
+/**
+ * Converts a free-flowing dashboard into a sectioned one: every existing
+ * untitled layout that holds panels is titled in place ("Section 1", "Section
+ * 2", …), then the brand-new section the user asked for is appended — all in one
+ * atomic patch. Used once the user confirms the migration prompt.
+ */
+export function useFirstSectionMigration({ sections }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [isSaving, setIsSaving] = useState(false);
+	const { showErrorModal } = useErrorModal();
+
+	const migrate = useCallback(
+		async (newSectionTitle: string): Promise<void> => {
+			const trimmed = newSectionTitle.trim();
+			if (!dashboardId || !trimmed) {
+				return;
+			}
+
+			const ops: DashboardtypesJSONPatchOperationDTO[] = [];
+			let counter = 1;
+			sections.forEach((s) => {
+				if (!s.title && s.items.length > 0) {
+					ops.push(titleUntitledSectionOp(s.layoutIndex, `Section ${counter}`));
+					counter += 1;
+				}
+			});
+			ops.push(addSectionOp(trimmed));
+
+			try {
+				setIsSaving(true);
+				await patchDashboardV2({ id: dashboardId }, ops);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			} finally {
+				setIsSaving(false);
+			}
+		},
+		[sections, dashboardId, refetch, showErrorModal],
+	);
+
+	return { migrate, isSaving };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/usePersistLayout.ts

@@ -0,0 +1,97 @@
+import { useCallback, useState } from 'react';
+import type { Layout } from 'react-grid-layout';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { replaceSectionItemsOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { GridItem } from '../../../utils';
+
+interface Params {
+	layoutIndex: number;
+	items: GridItem[];
+}
+
+interface Result {
+	handleLayoutChange: (rglLayout: Layout[]) => void;
+	isSaving: boolean;
+}
+
+/** Maps an RGL layout back onto the section's grid items, preserving panel refs. */
+function mergeRglLayout(rglLayout: Layout[], items: GridItem[]): GridItem[] {
+	const byId = new Map(items.map((item) => [item.id, item]));
+	return rglLayout
+		.map((entry) => {
+			const existing = byId.get(entry.i);
+			if (!existing) {
+				return null;
+			}
+			return {
+				...existing,
+				x: entry.x,
+				y: entry.y,
+				width: entry.w,
+				height: entry.h,
+			};
+		})
+		.filter((item): item is GridItem => item !== null);
+}
+
+function hasGeometryChanged(next: GridItem[], prev: GridItem[]): boolean {
+	if (next.length !== prev.length) {
+		return true;
+	}
+	const prevById = new Map(prev.map((item) => [item.id, item]));
+	return next.some((item) => {
+		const before = prevById.get(item.id);
+		if (!before) {
+			return true;
+		}
+		return (
+			before.x !== item.x ||
+			before.y !== item.y ||
+			before.width !== item.width ||
+			before.height !== item.height
+		);
+	});
+}
+
+/**
+ * Persists panel geometry within a single section. Call the returned handler
+ * from RGL's `onDragStop`/`onResizeStop` (stop events only — not continuous
+ * `onLayoutChange`) to limit network churn.
+ */
+export function usePersistLayout({ layoutIndex, items }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [isSaving, setIsSaving] = useState(false);
+	const { showErrorModal } = useErrorModal();
+
+	const handleLayoutChange = useCallback(
+		async (rglLayout: Layout[]): Promise<void> => {
+			if (!dashboardId) {
+				return;
+			}
+			const nextItems = mergeRglLayout(rglLayout, items);
+			if (!hasGeometryChanged(nextItems, items)) {
+				return;
+			}
+			try {
+				setIsSaving(true);
+				await patchDashboardV2({ id: dashboardId }, [
+					replaceSectionItemsOp(layoutIndex, nextItems),
+				]);
+				refetch();
+			} catch (error) {
+				showErrorModal(error as APIError);
+			} finally {
+				setIsSaving(false);
+			}
+		},
+		[dashboardId, items, layoutIndex, refetch, showErrorModal],
+	);
+
+	return { handleLayoutChange, isSaving };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useRenameSection.ts

@@ -0,0 +1,50 @@
+import { useCallback, useState } from 'react';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { renameSectionOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+
+interface Params {
+	layoutIndex: number;
+}
+
+interface Result {
+	rename: (title: string) => Promise<boolean>;
+	isSaving: boolean;
+}
+
+/** Renames a section's title via `replace /spec/layouts/<i>/spec/display/title`. */
+export function useRenameSection({ layoutIndex }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [isSaving, setIsSaving] = useState(false);
+	const { showErrorModal } = useErrorModal();
+
+	const rename = useCallback(
+		async (title: string): Promise<boolean> => {
+			const trimmed = title.trim();
+			if (!dashboardId || !trimmed) {
+				return false;
+			}
+			try {
+				setIsSaving(true);
+				await patchDashboardV2({ id: dashboardId }, [
+					renameSectionOp(layoutIndex, trimmed),
+				]);
+				refetch();
+				return true;
+			} catch (error) {
+				showErrorModal(error as APIError);
+				return false;
+			} finally {
+				setIsSaving(false);
+			}
+		},
+		[dashboardId, layoutIndex, refetch, showErrorModal],
+	);
+
+	return { rename, isSaving };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useSectionDragReorder.ts

@@ -0,0 +1,125 @@
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import {
+	type DragEndEvent,
+	type DragStartEvent,
+	KeyboardSensor,
+	PointerSensor,
+	useSensor,
+	useSensors,
+} from '@dnd-kit/core';
+import { arrayMove, sortableKeyboardCoordinates } from '@dnd-kit/sortable';
+
+import { patchDashboardV2 } from 'api/generated/services/dashboard';
+import type { DashboardtypesLayoutDTO } from 'api/generated/services/sigNoz.schemas';
+import { useErrorModal } from 'providers/ErrorModalProvider';
+import APIError from 'types/api/error';
+
+import { reorderLayoutsOp } from '../../../patchOps';
+import { useDashboardStore } from '../../../store/useDashboardStore';
+import type { DashboardSection } from '../../../utils';
+
+interface Params {
+	sections: DashboardSection[];
+	layouts: DashboardtypesLayoutDTO[] | undefined | null;
+}
+
+interface Result {
+	sensors: ReturnType<typeof useSensors>;
+	/** Display order — optimistically reordered on drop so the UI doesn't wait on refetch. */
+	orderedSections: DashboardSection[];
+	/** The section currently being dragged (for the DragOverlay preview), or null. */
+	activeSection: DashboardSection | null;
+	onDragStart: (event: DragStartEvent) => void;
+	onDragEnd: (event: DragEndEvent) => void;
+	onDragCancel: () => void;
+}
+
+/**
+ * Owns section-reorder drag state. Reorders happen optimistically in local
+ * state (keyed by stable section id) and persist via a single
+ * `replace /spec/layouts` patch; the optimistic order is cleared once fresh
+ * server data arrives. Each section maps 1:1 to a Grid layout via `layoutIndex`,
+ * so the new layouts array is rebuilt by mapping the reordered sections back.
+ */
+export function useSectionDragReorder({ sections, layouts }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const refetch = useDashboardStore((s) => s.refetch);
+	const [activeId, setActiveId] = useState<string | null>(null);
+	const [localOrderIds, setLocalOrderIds] = useState<string[] | null>(null);
+	const { showErrorModal } = useErrorModal();
+
+	const sensors = useSensors(
+		useSensor(PointerSensor, { activationConstraint: { distance: 5 } }),
+		useSensor(KeyboardSensor, { coordinateGetter: sortableKeyboardCoordinates }),
+	);
+
+	// Server data is the source of truth — drop optimistic order whenever it changes.
+	useEffect(() => {
+		setLocalOrderIds(null);
+	}, [sections]);
+
+	const orderedSections = useMemo<DashboardSection[]>(() => {
+		if (!localOrderIds) {
+			return sections;
+		}
+		const byId = new Map(sections.map((s) => [s.id, s]));
+		const ordered = localOrderIds
+			.map((id) => byId.get(id))
+			.filter((s): s is DashboardSection => s !== undefined);
+		return ordered.length === sections.length ? ordered : sections;
+	}, [sections, localOrderIds]);
+
+	const onDragStart = useCallback((event: DragStartEvent): void => {
+		setActiveId(String(event.active.id));
+	}, []);
+
+	const onDragCancel = useCallback((): void => {
+		setActiveId(null);
+	}, []);
+
+	const onDragEnd = useCallback(
+		async (event: DragEndEvent): Promise<void> => {
+			setActiveId(null);
+			const { active, over } = event;
+			if (!over || active.id === over.id || !dashboardId || !layouts) {
+				return;
+			}
+
+			const oldIndex = orderedSections.findIndex((s) => s.id === active.id);
+			const newIndex = orderedSections.findIndex((s) => s.id === over.id);
+			if (oldIndex < 0 || newIndex < 0) {
+				return;
+			}
+
+			const newOrdered = arrayMove(orderedSections, oldIndex, newIndex);
+			setLocalOrderIds(newOrdered.map((s) => s.id));
+
+			const newLayouts = newOrdered
+				.map((s) => layouts[s.layoutIndex])
+				.filter((l): l is DashboardtypesLayoutDTO => l !== undefined);
+
+			try {
+				await patchDashboardV2({ id: dashboardId }, [reorderLayoutsOp(newLayouts)]);
+				refetch();
+			} catch (error) {
+				setLocalOrderIds(null); // revert optimistic order on failure
+				showErrorModal(error as APIError);
+			}
+		},
+		[orderedSections, layouts, dashboardId, refetch, showErrorModal],
+	);
+
+	const activeSection = useMemo(
+		() => orderedSections.find((s) => s.id === activeId) ?? null,
+		[orderedSections, activeId],
+	);
+
+	return {
+		sensors,
+		orderedSections,
+		activeSection,
+		onDragStart,
+		onDragEnd,
+		onDragCancel,
+	};
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/PanelsAndSectionsLayout/Section/hooks/useToggleSectionCollapse.ts

@@ -0,0 +1,36 @@
+import { useCallback } from 'react';
+
+import {
+	selectIsSectionOpen,
+	useDashboardStore,
+} from '../../../store/useDashboardStore';
+
+interface Params {
+	sectionId: string;
+}
+
+interface Result {
+	open: boolean;
+	toggle: () => void;
+}
+
+/**
+ * Owns a section's expand/collapse state. Collapse is a frontend-only, per-user
+ * preference (not in the dashboard spec): it lives in the persisted zustand
+ * store, keyed by dashboardId + section id, and survives reloads. Default open.
+ */
+export function useToggleSectionCollapse({ sectionId }: Params): Result {
+	const dashboardId = useDashboardStore((s) => s.dashboardId);
+	const open = useDashboardStore(selectIsSectionOpen(dashboardId, sectionId));
+	const toggleSectionCollapse = useDashboardStore(
+		(s) => s.toggleSectionCollapse,
+	);
+
+	const toggle = useCallback((): void => {
+		if (dashboardId) {
+			toggleSectionCollapse(dashboardId, sectionId);
+		}
+	}, [dashboardId, sectionId, toggleSectionCollapse]);
+
+	return { open, toggle };
+}

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

@@ -7,8 +7,11 @@ import type {
 	DashboardtypesPanelDTO,
 } from 'api/generated/services/sigNoz.schemas';
 
+import { useDashboardStore } from '../store/useDashboardStore';
 import { layoutsToSections } from '../utils';
+import AddSectionControl from './Section/AddSectionControl/AddSectionControl';
 import Section from './Section/Section/Section';
+import SectionList from './Section/SectionList';
 import styles from './PanelsAndSectionsLayout.module.scss';
 
 import 'react-grid-layout/css/styles.css';
@@ -20,6 +23,8 @@ interface Props {
 }
 
 function PanelsAndSectionsLayout({ layouts, panels }: Props): JSX.Element {
+	const isEditable = useDashboardStore((s) => s.isEditable);
+
 	const sections = useMemo(
 		() => layoutsToSections(layouts, panels),
 		[layouts, panels],
@@ -28,6 +33,11 @@ function PanelsAndSectionsLayout({ layouts, panels }: Props): JSX.Element {
 	const isEmpty =
 		sections.length === 0 || sections.every((s) => s.items.length === 0);
 
+	// Sectioned mode = at least one titled layout. Sections then become a
+	// reorderable list; otherwise the dashboard is a single free-flowing grid
+	// with no section chrome or reordering.
+	const isSectioned = useMemo(() => sections.some((s) => !!s.title), [sections]);
+
 	const renderContent = (): ReactNode => {
 		if (isEmpty) {
 			return (
@@ -42,12 +52,27 @@ function PanelsAndSectionsLayout({ layouts, panels }: Props): JSX.Element {
 			);
 		}
 
+		if (isSectioned) {
+			return <SectionList sections={sections} layouts={layouts} />;
+		}
+
 		return sections.map((section) => (
 			<Section key={section.id} section={section} />
 		));
 	};
 
-	return <div className={styles.body}>{renderContent()}</div>;
+	return (
+		<div className={styles.body}>
+			{renderContent()}
+			{isEditable ? (
+				<AddSectionControl
+					sections={sections}
+					layouts={layouts}
+					isSectioned={isSectioned}
+				/>
+			) : null}
+		</div>
+	);
 }
 
 export default PanelsAndSectionsLayout;

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

@@ -1,10 +1,13 @@
-import { useMemo } from 'react';
+import { useEffect, useMemo } from 'react';
 import { FullScreen, useFullScreenHandle } from 'react-full-screen';
 
 import type { DashboardtypesGettableDashboardV2DTO } from 'api/generated/services/sigNoz.schemas';
+import useComponentPermission from 'hooks/useComponentPermission';
+import { useAppContext } from 'providers/App/App';
 
 import DashboardDescription from './DashboardDescription';
 import PanelsAndSectionsLayout from './PanelsAndSectionsLayout';
+import { useDashboardStore } from './store/useDashboardStore';
 import styles from './DashboardContainer.module.scss';
 
 interface Props {
@@ -15,6 +18,17 @@ interface Props {
 function DashboardContainer({ dashboard, refetch }: Props): JSX.Element {
 	const fullScreenHandle = useFullScreenHandle();
 
+	const { user } = useAppContext();
+	const [editDashboard] = useComponentPermission(['edit_dashboard'], user.role);
+	const isEditable = !dashboard.locked && editDashboard;
+
+	// Publish edit context to the store so hooks/components read it from there
+	// instead of receiving dashboardId/isEditable/refetch as props down the tree.
+	const setEditContext = useDashboardStore((s) => s.setEditContext);
+	useEffect(() => {
+		setEditContext({ dashboardId: dashboard.id ?? '', isEditable, refetch });
+	}, [dashboard.id, isEditable, refetch, setEditContext]);
+
 	const { spec } = dashboard;
 	const layouts = useMemo(() => spec?.layouts ?? [], [spec?.layouts]);
 	const panels = useMemo(() => spec?.panels ?? {}, [spec?.panels]);

frontend/src/pages/DashboardPageV2/DashboardContainer/patchOps.ts

@@ -0,0 +1,177 @@
+import type {
+	DashboardGridItemDTO,
+	DashboardtypesJSONPatchOperationDTO,
+	DashboardtypesLayoutDTO,
+	DashboardtypesPanelDTO,
+} from 'api/generated/services/sigNoz.schemas';
+import { DashboardtypesJSONPatchOperationDTOOp } from 'api/generated/services/sigNoz.schemas';
+
+import type { GridItem } from './utils';
+
+/**
+ * Pure RFC-6902 JSON-Patch builders for the V2 dashboard spec. These are
+ * intentionally side-effect-free (no React, no network) so they can be unit
+ * tested and reused by the layout hooks. JSON pointers target the postable
+ * shape: `/spec/layouts/...`, `/spec/panels/...` (matches the existing V2
+ * patches in DashboardSettings/General and DashboardDescription).
+ */
+
+const { add, replace, remove } = DashboardtypesJSONPatchOperationDTOOp;
+
+const PANEL_REF_PREFIX = '#/spec/panels/';
+
+export function panelRef(panelId: string): string {
+	return `${PANEL_REF_PREFIX}${panelId}`;
+}
+
+/**
+ * Builds a minimal, backend-valid panel for a given plugin kind. The spec
+ * requires exactly one query whose plugin kind is allowed for the panel;
+ * `signoz/BuilderQuery` is allowed for every panel kind and its contents are not
+ * validated, so an empty builder query is the safe default. The real query is
+ * filled in once the panel editor lands.
+ */
+export function createDefaultPanel(pluginKind: string): DashboardtypesPanelDTO {
+	// The DTO types plugin/query kinds as large generated enum unions; the kind
+	// here is chosen dynamically by the user, so we build the structurally-valid
+	// shape and assert the type.
+	return {
+		kind: 'Panel',
+		spec: {
+			display: { name: 'New panel' },
+			plugin: { kind: pluginKind, spec: {} },
+			queries: [
+				{
+					kind: 'TimeSeriesQuery',
+					spec: { plugin: { kind: 'signoz/BuilderQuery', spec: { name: 'A' } } },
+				},
+			],
+		},
+	} as unknown as DashboardtypesPanelDTO;
+}
+
+/** Converts a UI grid item back into the spec's grid-item DTO shape. */
+export function gridItemToDTO(item: GridItem): DashboardGridItemDTO {
+	return {
+		x: item.x,
+		y: item.y,
+		width: item.width,
+		height: item.height,
+		content: { $ref: panelRef(item.id) },
+	};
+}
+
+/** Replace the entire items array of one section (used on panel move/resize). */
+export function replaceSectionItemsOp(
+	layoutIndex: number,
+	items: GridItem[],
+): DashboardtypesJSONPatchOperationDTO {
+	return {
+		op: replace,
+		path: `/spec/layouts/${layoutIndex}/spec/items`,
+		value: items.map(gridItemToDTO),
+	};
+}
+
+/** Replace the whole layouts array (used on section reorder — avoids move-index ambiguity). */
+export function reorderLayoutsOp(
+	layouts: DashboardtypesLayoutDTO[],
+): DashboardtypesJSONPatchOperationDTO {
+	return { op: replace, path: '/spec/layouts', value: layouts };
+}
+
+/** An empty titled Grid layout (one section). */
+export function newGridLayout(title: string): DashboardtypesLayoutDTO {
+	return {
+		kind: 'Grid' as DashboardtypesLayoutDTO['kind'],
+		spec: { display: { title }, items: [] },
+	};
+}
+
+/** Append a new, empty titled Grid section. */
+export function addSectionOp(
+	title: string,
+): DashboardtypesJSONPatchOperationDTO {
+	return { op: add, path: '/spec/layouts/-', value: newGridLayout(title) };
+}
+
+interface AddPanelToSectionArgs {
+	panelId: string;
+	panel: DashboardtypesPanelDTO;
+	layoutIndex: number;
+	item: DashboardGridItemDTO;
+}
+
+/** Add a panel to `spec.panels` and an item ref into a section, as one atomic patch. */
+export function addPanelToSectionOps({
+	panelId,
+	panel,
+	layoutIndex,
+	item,
+}: AddPanelToSectionArgs): DashboardtypesJSONPatchOperationDTO[] {
+	return [
+		{ op: add, path: `/spec/panels/${panelId}`, value: panel },
+		{ op: add, path: `/spec/layouts/${layoutIndex}/spec/items/-`, value: item },
+	];
+}
+
+interface MovePanelArgs {
+	sourceIndex: number;
+	sourceItems: GridItem[];
+	targetIndex: number;
+	targetItems: GridItem[];
+}
+
+/** Move a panel's item ref from one section to another (panel stays in spec.panels). */
+export function movePanelBetweenSectionsOps({
+	sourceIndex,
+	sourceItems,
+	targetIndex,
+	targetItems,
+}: MovePanelArgs): DashboardtypesJSONPatchOperationDTO[] {
+	return [
+		replaceSectionItemsOp(sourceIndex, sourceItems),
+		replaceSectionItemsOp(targetIndex, targetItems),
+	];
+}
+
+/** Rename an existing section's title. */
+export function renameSectionOp(
+	layoutIndex: number,
+	title: string,
+): DashboardtypesJSONPatchOperationDTO {
+	return {
+		op: replace,
+		path: `/spec/layouts/${layoutIndex}/spec/display/title`,
+		value: title,
+	};
+}
+
+/**
+ * First-section migration: give an existing untitled (free-flowing) layout a
+ * title, turning it into a section in place while preserving its panels.
+ */
+export function titleUntitledSectionOp(
+	layoutIndex: number,
+	title: string,
+): DashboardtypesJSONPatchOperationDTO {
+	return {
+		op: add,
+		path: `/spec/layouts/${layoutIndex}/spec/display`,
+		value: { title },
+	};
+}
+
+/** Remove a section. Panel cleanup (orphaned refs) is handled by the caller. */
+export function removeSectionOp(
+	layoutIndex: number,
+): DashboardtypesJSONPatchOperationDTO {
+	return { op: remove, path: `/spec/layouts/${layoutIndex}` };
+}
+
+/** Remove a panel definition from `spec.panels`. */
+export function removePanelOp(
+	panelId: string,
+): DashboardtypesJSONPatchOperationDTO {
+	return { op: remove, path: `/spec/panels/${panelId}` };
+}

frontend/src/pages/DashboardPageV2/DashboardContainer/store/slices/collapseSlice.ts

@@ -0,0 +1,35 @@
+import type { StateCreator } from 'zustand';
+
+import type { DashboardStore } from '../useDashboardStore';
+
+/**
+ * Section collapse state — frontend-only and persisted to localStorage. Keyed by
+ * dashboardId → section stable id → open. An absent entry means "open" (the
+ * default). This is intentionally NOT server state: collapse is a per-user UI
+ * preference, so it lives here instead of in the dashboard spec.
+ */
+export interface CollapseSlice {
+	collapsed: Record<string, Record<string, boolean>>;
+	toggleSectionCollapse: (dashboardId: string, sectionId: string) => void;
+}
+
+export const createCollapseSlice: StateCreator<
+	DashboardStore,
+	[['zustand/persist', unknown]],
+	[],
+	CollapseSlice
+> = (set, get) => ({
+	collapsed: {},
+	toggleSectionCollapse: (dashboardId, sectionId): void => {
+		const { collapsed } = get();
+		const current = collapsed[dashboardId]?.[sectionId];
+		// Absent → open by default, so the first toggle closes it.
+		const next = current === undefined ? false : !current;
+		set({
+			collapsed: {
+				...collapsed,
+				[dashboardId]: { ...collapsed[dashboardId], [sectionId]: next },
+			},
+		});
+	},
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/store/slices/editContextSlice.ts

@@ -0,0 +1,38 @@
+import type { StateCreator } from 'zustand';
+
+import type { DashboardStore } from '../useDashboardStore';
+
+/**
+ * Edit context shared across the V2 dashboard tree — the dashboard id, whether
+ * the user can edit, and the react-query refetch. Set once by DashboardContainer
+ * so hooks/components read it from the store instead of receiving it as props
+ * through every layer. Not persisted.
+ */
+export interface EditContextSlice {
+	dashboardId: string;
+	isEditable: boolean;
+	refetch: () => void;
+	setEditContext: (ctx: {
+		dashboardId: string;
+		isEditable: boolean;
+		refetch: () => void;
+	}) => void;
+}
+
+export const createEditContextSlice: StateCreator<
+	DashboardStore,
+	[['zustand/persist', unknown]],
+	[],
+	EditContextSlice
+> = (set) => ({
+	dashboardId: '',
+	isEditable: false,
+	refetch: (): void => undefined,
+	setEditContext: (ctx): void => {
+		set({
+			dashboardId: ctx.dashboardId,
+			isEditable: ctx.isEditable,
+			refetch: ctx.refetch,
+		});
+	},
+});

frontend/src/pages/DashboardPageV2/DashboardContainer/store/useDashboardStore.ts

@@ -0,0 +1,44 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+import {
+	createEditContextSlice,
+	type EditContextSlice,
+} from './slices/editContextSlice';
+import {
+	createCollapseSlice,
+	type CollapseSlice,
+} from './slices/collapseSlice';
+
+export type DashboardStore = EditContextSlice & CollapseSlice;
+
+/**
+ * V2 dashboard session store. Holds cross-cutting client state only — never the
+ * dashboard spec (that stays in react-query via useGetDashboardV2). Two slices:
+ * - edit-context: dashboardId / isEditable / refetch (set once, not persisted).
+ * - collapse: per-section open state (frontend-only, persisted to localStorage).
+ */
+export const useDashboardStore = create<DashboardStore>()(
+	persist(
+		(...a) => ({
+			...createEditContextSlice(...a),
+			...createCollapseSlice(...a),
+		}),
+		{
+			name: '@signoz/dashboard-v2',
+			// Persist only the collapse map — context (incl. the refetch fn) is transient.
+			partialize: (state) => ({ collapsed: state.collapsed }),
+		},
+	),
+);
+
+/** Selector: is a section open? Absent entry (or no dashboard) → open by default. */
+export const selectIsSectionOpen =
+	(dashboardId: string, sectionId: string) =>
+	(state: DashboardStore): boolean => {
+		if (!dashboardId) {
+			return true;
+		}
+		const value = state.collapsed[dashboardId]?.[sectionId];
+		return value === undefined ? true : value;
+	};

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

@@ -72,7 +72,6 @@ export interface DashboardSection {
 	/** Position of this section's Grid in `spec.layouts`. All JSON-Patch ops target by this. */
 	layoutIndex: number;
 	title: string | undefined;
-	open: boolean;
 	items: GridItem[];
 	repeatVariable: string | undefined;
 }
@@ -127,15 +126,11 @@ export function layoutsToSections(
 				.filter((it): it is GridItem => it !== null);
 
 			const title = spec?.display?.title;
-			// `open` defaults to true when no collapse field is set (the section
-			// is expanded by default).
-			const open = spec?.display?.collapse?.open !== false;
 
 			return {
 				id: getSectionStableId(items, idx),
 				layoutIndex: idx,
 				title,
-				open,
 				items,
 				repeatVariable: spec?.repeatVariable,
 			};

pkg/querier/querier.go

@@ -86,12 +86,11 @@ func New(
 
 func (q *querier) QueryRange(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest) (*qbtypes.QueryRangeResponse, error) {
 
-	// Normalize Start/End to ms. UnmarshalJSON covers HTTP requests; callers
-	// that build the request programmatically skip it, so this is the catch-all
-	// (idempotent for the already-normalized path).
-	if err := req.Normalize(); err != nil {
-		return nil, err
-	}
+	// Coerce the window to epoch milliseconds up front so every downstream
+	// consumer (TimeRange, narrowWindowByTraceID, step interval, etc.) can
+	// safely assume ms regardless of the resolution the caller sent.
+	req.Start = querybuilder.ToMilliSecs(req.Start)
+	req.End = querybuilder.ToMilliSecs(req.End)
 
 	tmplVars := req.Variables
 	if tmplVars == nil {
@@ -428,12 +427,10 @@ func (q *querier) resolveMetricMetadata(ctx context.Context, queries []qbtypes.Q
 
 func (q *querier) QueryRawStream(ctx context.Context, orgID valuer.UUID, req *qbtypes.QueryRangeRequest, client *qbtypes.RawStream) {
 
-	// Catch-all normalization for programmatic callers (see QueryRange). End is
-	// 0 here for the open-ended stream, which Normalize leaves untouched.
-	if err := req.Normalize(); err != nil {
-		client.Error <- err
-		return
-	}
+	// Coerce the window to epoch milliseconds up front (End may be 0 for the
+	// open-ended stream, which ToMilliSecs leaves untouched).
+	req.Start = querybuilder.ToMilliSecs(req.Start)
+	req.End = querybuilder.ToMilliSecs(req.End)
 
 	event := &qbtypes.QBEvent{
 		Version:         "v5",

pkg/querybuilder/time.go

@@ -33,6 +33,28 @@ func ToNanoSecs(epoch uint64) uint64 {
 	return temp * uint64(math.Pow(10, float64(19-count)))
 }
 
+// ToMilliSecs takes an epoch whose resolution is inferred from its magnitude
+// (s/ms/µs/ns) and returns it in milliseconds. A millisecond epoch for the
+// current era has 13 digits (e.g. ~1.7e12 in 2026), so the value is scaled so
+// its digit-width matches: smaller values (seconds) are scaled up, larger ones
+// (micro/nanoseconds) are scaled down. Zero is returned unchanged.
+func ToMilliSecs(epoch uint64) uint64 {
+	if epoch == 0 {
+		return 0
+	}
+	temp := epoch
+	count := 0
+	for epoch != 0 {
+		epoch /= 10
+		count++
+	}
+	const msDigits = 13
+	if count < msDigits {
+		return temp * uint64(math.Pow(10, float64(msDigits-count)))
+	}
+	return temp / uint64(math.Pow(10, float64(count-msDigits)))
+}
+
 // TODO(srikanthccv): should these be rounded to nearest multiple of 60 instead of 5 if step > 60?
 // That would make graph look nice but "nice" but should be less important than the usefulness.
 func RecommendedStepInterval(start, end uint64) uint64 {

pkg/querybuilder/time_test.go

@@ -60,3 +60,51 @@ func TestToNanoSecs(t *testing.T) {
 		})
 	}
 }
+
+func TestToMilliSecs(t *testing.T) {
+	tests := []struct {
+		name     string
+		epoch    uint64
+		expected uint64
+	}{
+		{
+			name:     "10-digit Unix timestamp (seconds) - 2023-01-01 00:00:00 UTC",
+			epoch:    1672531200,    // seconds
+			expected: 1672531200000, // * 10^3
+		},
+		{
+			name:     "13-digit Unix timestamp (milliseconds) - already ms",
+			epoch:    1672531200000,
+			expected: 1672531200000, // unchanged
+		},
+		{
+			name:     "16-digit Unix timestamp (microseconds)",
+			epoch:    1672531200000000, // microseconds
+			expected: 1672531200000,    // / 10^3
+		},
+		{
+			name:     "19-digit Unix timestamp (nanoseconds)",
+			epoch:    1672531200000000000, // nanoseconds
+			expected: 1672531200000,       // / 10^6
+		},
+		{
+			name:     "Unix epoch start - zero is unchanged",
+			epoch:    0,
+			expected: 0,
+		},
+		{
+			name:     "Recent timestamp in seconds - 2024-05-25 12:00:00 UTC",
+			epoch:    1716638400,
+			expected: 1716638400000,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ToMilliSecs(tt.epoch)
+			if result != tt.expected {
+				t.Errorf("ToMilliSecs(%d) = %d, want %d", tt.epoch, result, tt.expected)
+			}
+		})
+	}
+}

pkg/types/querybuildertypes/querybuildertypesv5/req.go

@@ -12,13 +12,6 @@ import (
 	"github.com/swaggest/jsonschema-go"
 )
 
-const (
-	// minEpochMs and maxEpochMs bound a plausible ms timestamp to
-	// 1990-01-01 .. 2100-01-01, used to reject malformed Start/End values.
-	minEpochMs uint64 = 631_152_000_000
-	maxEpochMs uint64 = 4_102_444_800_000
-)
-
 type QueryEnvelope struct {
 	// Type is the type of the query.
 	Type QueryType `json:"type"` // "builder_query" | "builder_formula" | "builder_sub_query" | "builder_join" | "promql" | "clickhouse_sql"
@@ -556,23 +549,7 @@ func (r *QueryRangeRequest) SkipFillGaps(name string) bool {
 	return false
 }
 
-// Normalize coerces Start and End to epoch milliseconds, inferring the source
-// resolution (s/ms/µs/ns) from each value's magnitude, and rejects non-zero
-// values outside the plausible 1990-2100 range. Lets downstream consumers
-// assume ms regardless of what the caller sent.
-func (r *QueryRangeRequest) Normalize() error {
-	start, err := toMilliSecs(r.Start)
-	if err != nil {
-		return err
-	}
-	end, err := toMilliSecs(r.End)
-	if err != nil {
-		return err
-	}
-	r.Start, r.End = start, end
-	return nil
-}
-
+// UnmarshalJSON implements custom JSON unmarshaling to disallow unknown fields.
 func (r *QueryRangeRequest) UnmarshalJSON(data []byte) error {
 	// Define a type alias to avoid infinite recursion
 	type Alias QueryRangeRequest
@@ -632,11 +609,6 @@ func (r *QueryRangeRequest) UnmarshalJSON(data []byte) error {
 	// Copy the decoded values back to the original struct
 	*r = QueryRangeRequest(temp)
 
-	// Coerce Start/End to ms (and validate) at decode time for HTTP requests.
-	if err := r.Normalize(); err != nil {
-		return err
-	}
-
 	return nil
 }
 
@@ -690,24 +662,3 @@ func (r *QueryRangeRequest) GetQueriesSupportingZeroDefault() map[string]bool {
 
 	return canDefaultZero
 }
-
-// toMilliSecs scales an epoch to milliseconds based on its magnitude: seconds are
-// scaled up, micro/nanoseconds down, milliseconds left as-is. Zero is returned
-// unchanged. A non-zero result outside 1990-2100 is rejected as malformed.
-func toMilliSecs(epoch uint64) (uint64, error) {
-	var ms uint64
-	switch {
-	case epoch < 1e12: // seconds
-		ms = epoch * 1_000
-	case epoch < 1e15: // milliseconds
-		ms = epoch
-	case epoch < 1e18: // microseconds
-		ms = epoch / 1_000
-	default: // nanoseconds
-		ms = epoch / 1_000_000
-	}
-	if epoch != 0 && (ms < minEpochMs || ms > maxEpochMs) {
-		return 0, errors.NewInvalidInputf(errors.CodeInvalidInput, "timestamp %d is outside the supported range (1990-2100)", epoch)
-	}
-	return ms, nil
-}

pkg/types/querybuildertypes/querybuildertypesv5/req_test.go

@@ -1903,70 +1903,3 @@ func TestQueryRangeRequest_StepIntervalForQuery(t *testing.T) {
 		})
 	}
 }
-
-func TestQueryRangeRequest_Normalize(t *testing.T) {
-	tests := []struct {
-		name      string
-		start     uint64
-		end       uint64
-		wantStart uint64
-		wantEnd   uint64
-		wantErr   bool
-	}{
-		{
-			name:      "seconds are scaled up to ms",
-			start:     1672531200,    // 2023-01-01 in seconds
-			end:       1716638400,    // 2024-05-25 in seconds
-			wantStart: 1672531200000, // * 10^3
-			wantEnd:   1716638400000,
-		},
-		{
-			name:      "milliseconds pass through unchanged",
-			start:     1672531200000,
-			end:       1716638400000,
-			wantStart: 1672531200000,
-			wantEnd:   1716638400000,
-		},
-		{
-			name:      "microseconds are scaled down to ms",
-			start:     1672531200000000, // µs
-			end:       1716638400000000,
-			wantStart: 1672531200000, // / 10^3
-			wantEnd:   1716638400000,
-		},
-		{
-			name:      "nanoseconds are scaled down to ms",
-			start:     1672531200000000000, // ns
-			end:       1716638400000000000,
-			wantStart: 1672531200000, // / 10^6
-			wantEnd:   1716638400000,
-		},
-		{
-			name:      "zero end (open-ended stream) is left untouched",
-			start:     1672531200000,
-			end:       0,
-			wantStart: 1672531200000,
-			wantEnd:   0,
-		},
-		{
-			name:    "out-of-range timestamp is rejected",
-			start:   5_000_000_000_000, // ~year 2128 in ms, beyond the 2100 bound
-			end:     5_000_000_000_000,
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			r := &QueryRangeRequest{Start: tt.start, End: tt.end}
-			err := r.Normalize()
-			if tt.wantErr {
-				require.Error(t, err)
-				return
-			}
-			require.NoError(t, err)
-			assert.Equal(t, tt.wantStart, r.Start)
-			assert.Equal(t, tt.wantEnd, r.End)
-		})
-	}
-}

tests/integration/testdata/inframonitoring/hosts_filter_dataset.jsonl

@@ -0,0 +1,144 @@
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "user"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "user"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "user"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 300, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "system"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "system"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "system"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 150, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "idle"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 400, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "idle"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 600, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "idle"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 800, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "wait"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 10, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "wait"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 20, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "wait"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 30, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2100000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2200000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 6000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 5900000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 5800000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "buffered"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "buffered"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "buffered"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "cached"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "cached"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "cached"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "prod-linux-1", "os.type": "linux"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "prod-linux-1", "os.type": "linux"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1.55, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "prod-linux-1", "os.type": "linux"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 51000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 52000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 49000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 48000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "reserved"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "reserved"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-linux-1", "os.type": "linux", "state": "reserved"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "user"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "user"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "user"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 300, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "system"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "system"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "system"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 150, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "idle"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 400, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "idle"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 600, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "idle"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 800, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "wait"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 10, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "wait"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 20, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "wait"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 30, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2100000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2200000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 6000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 5900000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 5800000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "buffered"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "buffered"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "buffered"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "cached"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "cached"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "cached"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "prod-windows-1", "os.type": "windows"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "prod-windows-1", "os.type": "windows"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1.55, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "prod-windows-1", "os.type": "windows"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 51000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 52000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 49000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 48000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "reserved"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "reserved"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "prod-windows-1", "os.type": "windows", "state": "reserved"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "user"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "user"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "user"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 300, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "system"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "system"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "system"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 150, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "idle"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 400, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "idle"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 600, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "idle"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 800, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "wait"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 10, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "wait"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 20, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "wait"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 30, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2100000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2200000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 6000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 5900000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 5800000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "buffered"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "buffered"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "buffered"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "cached"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "cached"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "cached"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "dev-linux-1", "os.type": "linux"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "dev-linux-1", "os.type": "linux"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1.55, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "dev-linux-1", "os.type": "linux"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 51000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "used"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 52000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 49000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "free"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 48000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "reserved"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "reserved"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-linux-1", "os.type": "linux", "state": "reserved"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "user"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "user"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 200, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "user"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 300, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "system"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "system"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "system"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 150, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "idle"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 400, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "idle"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 600, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "idle"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 800, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "wait"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 10, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "wait"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 20, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.cpu.time", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "wait"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 30, "temporality": "Cumulative", "type_": "Sum", "is_monotonic": true}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 2000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 2100000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2200000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 6000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 5900000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 5800000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "buffered"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "buffered"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "buffered"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "cached"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "cached"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.memory.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "cached"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1500000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "dev-windows-1", "os.type": "windows"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 1.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "dev-windows-1", "os.type": "windows"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 1.55, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.cpu.load_average.15m", "labels": {"host.name": "dev-windows-1", "os.type": "windows"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 1.6, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 51000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "used"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 52000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 50000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 49000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "free"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 48000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "reserved"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "reserved"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}
+{"metric_name": "system.filesystem.usage", "labels": {"host.name": "dev-windows-1", "os.type": "windows", "state": "reserved"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 5000000000, "temporality": "Unspecified", "type_": "Sum", "is_monotonic": false}

tests/integration/testdata/inframonitoring/hosts_groupby_os_type.jsonl

@@ -0,0 +1,126 @@
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-linux-1","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-linux-1","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-linux-1","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-windows-1","os.type":"windows"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-windows-1","os.type":"windows"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-windows-1","os.type":"windows"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-windows-2","os.type":"windows"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-windows-2","os.type":"windows"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-windows-2","os.type":"windows"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-windows-2","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:20:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:22:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:24:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:20:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:22:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:24:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:20:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:22:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:24:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:20:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:22:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:24:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-linux-1","os.type":"linux"},"timestamp":"2025-01-10T10:20:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-linux-1","os.type":"linux"},"timestamp":"2025-01-10T10:22:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-linux-1","os.type":"linux"},"timestamp":"2025-01-10T10:24:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:20:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:22:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:24:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:20:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:22:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:24:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:20:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:22:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:24:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:20:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:22:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-linux-2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:24:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:20:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:22:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:24:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:20:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:22:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:24:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-linux-2","os.type":"linux"},"timestamp":"2025-01-10T10:20:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-linux-2","os.type":"linux"},"timestamp":"2025-01-10T10:22:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-linux-2","os.type":"linux"},"timestamp":"2025-01-10T10:24:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:20:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:22:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:24:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:20:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:22:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-linux-2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:24:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-windows-1","os.type":"windows","state":"user"},"timestamp":"2025-01-10T10:20:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-windows-1","os.type":"windows","state":"user"},"timestamp":"2025-01-10T10:22:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-windows-1","os.type":"windows","state":"user"},"timestamp":"2025-01-10T10:24:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-windows-1","os.type":"windows","state":"idle"},"timestamp":"2025-01-10T10:20:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-windows-1","os.type":"windows","state":"idle"},"timestamp":"2025-01-10T10:22:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-windows-1","os.type":"windows","state":"idle"},"timestamp":"2025-01-10T10:24:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:20:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:22:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:24:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:20:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:22:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:24:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-windows-1","os.type":"windows"},"timestamp":"2025-01-10T10:20:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-windows-1","os.type":"windows"},"timestamp":"2025-01-10T10:22:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-windows-1","os.type":"windows"},"timestamp":"2025-01-10T10:24:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:20:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:22:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"used"},"timestamp":"2025-01-10T10:24:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:20:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:22:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-windows-1","os.type":"windows","state":"free"},"timestamp":"2025-01-10T10:24:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}

tests/integration/testdata/inframonitoring/hosts_missing_metrics.jsonl

@@ -0,0 +1,12 @@
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"system"},"timestamp":"2025-01-10T10:00:00+00:00","value":50,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"system"},"timestamp":"2025-01-10T10:02:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"system"},"timestamp":"2025-01-10T10:04:00+00:00","value":150,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:00:00+00:00","value":10,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:02:00+00:00","value":20,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"miss-h1","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:04:00+00:00","value":30,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}

tests/integration/testdata/inframonitoring/hosts_orderby.jsonl

@@ -0,0 +1,120 @@
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h1","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:00:00+00:00","value":10,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h1","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:02:00+00:00","value":20,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h1","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:04:00+00:00","value":30,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h1","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h1","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h1","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:10+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:10+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:10+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:10+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:10+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:10+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h2","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:00:10+00:00","value":10,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h2","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:02:10+00:00","value":20,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h2","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:04:10+00:00","value":30,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:10+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:10+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:10+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:10+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:10+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:10+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h2","os.type":"linux"},"timestamp":"2025-01-10T10:00:10+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h2","os.type":"linux"},"timestamp":"2025-01-10T10:02:10+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h2","os.type":"linux"},"timestamp":"2025-01-10T10:04:10+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:10+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:10+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:10+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:10+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:10+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:10+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h3","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:20+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h3","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:20+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h3","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:20+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h3","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:20+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h3","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:20+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h3","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:20+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h3","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:00:20+00:00","value":10,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h3","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:02:20+00:00","value":20,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h3","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:04:20+00:00","value":30,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:20+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:20+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:20+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:20+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:20+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:20+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h3","os.type":"linux"},"timestamp":"2025-01-10T10:00:20+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h3","os.type":"linux"},"timestamp":"2025-01-10T10:02:20+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h3","os.type":"linux"},"timestamp":"2025-01-10T10:04:20+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:20+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:20+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:20+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:20+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:20+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:20+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h4","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:30+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h4","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:30+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h4","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:30+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h4","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:30+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h4","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:30+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h4","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:30+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h4","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:00:30+00:00","value":10,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h4","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:02:30+00:00","value":20,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h4","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:04:30+00:00","value":30,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:30+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:30+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:30+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:30+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:30+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:30+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h4","os.type":"linux"},"timestamp":"2025-01-10T10:00:30+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h4","os.type":"linux"},"timestamp":"2025-01-10T10:02:30+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h4","os.type":"linux"},"timestamp":"2025-01-10T10:04:30+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:30+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:30+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:30+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:30+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:30+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:30+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h5","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:40+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h5","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:40+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h5","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:40+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h5","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:40+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h5","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:40+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h5","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:40+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h5","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:00:40+00:00","value":10,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h5","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:02:40+00:00","value":20,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"order-h5","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:04:40+00:00","value":30,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:40+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:40+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:40+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:40+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:40+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:40+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h5","os.type":"linux"},"timestamp":"2025-01-10T10:00:40+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h5","os.type":"linux"},"timestamp":"2025-01-10T10:02:40+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"order-h5","os.type":"linux"},"timestamp":"2025-01-10T10:04:40+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:40+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:40+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:40+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:40+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:40+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"order-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:40+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}

tests/integration/testdata/inframonitoring/hosts_pagination.jsonl

@@ -0,0 +1,147 @@
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":50,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h1","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h1","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h1","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h2","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h2","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h2","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h3","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h3","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":150,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h3","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h3","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h3","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h3","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h3","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h3","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h3","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h3","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h4","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h4","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h4","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h4","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h4","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h4","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h4","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h4","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h4","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h4","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h5","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h5","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":250,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h5","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":500,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h5","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h5","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h5","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h5","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h5","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h5","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h5","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h6","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h6","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h6","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h6","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h6","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h6","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h6","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h6","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h6","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h6","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h7","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":0,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h7","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":350,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h7","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":700,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h7","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h7","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"page-h7","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h7","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h7","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"page-h7","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"page-h7","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}

tests/integration/testdata/inframonitoring/hosts_status.jsonl

@@ -0,0 +1,42 @@
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"inactive-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-h1","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-h1","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"inactive-h1","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"inactive-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:20:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:22:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:24:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:20:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:22:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"active-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:24:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:20:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:22:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:24:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:20:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:22:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:24:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-h1","os.type":"linux"},"timestamp":"2025-01-10T10:20:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-h1","os.type":"linux"},"timestamp":"2025-01-10T10:22:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"active-h1","os.type":"linux"},"timestamp":"2025-01-10T10:24:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:20:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:22:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:24:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:20:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:22:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"active-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:24:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}

tests/integration/testdata/inframonitoring/hosts_value_accuracy.jsonl

@@ -0,0 +1,72 @@
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":200,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"system"},"timestamp":"2025-01-10T10:00:00+00:00","value":50,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"system"},"timestamp":"2025-01-10T10:02:00+00:00","value":100,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"system"},"timestamp":"2025-01-10T10:04:00+00:00","value":150,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":400,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":600,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":800,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:00:00+00:00","value":10,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:02:00+00:00","value":20,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h1","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:04:00+00:00","value":30,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:00:00+00:00","value":80,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:02:00+00:00","value":160,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"user"},"timestamp":"2025-01-10T10:04:00+00:00","value":240,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"system"},"timestamp":"2025-01-10T10:00:00+00:00","value":40,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"system"},"timestamp":"2025-01-10T10:02:00+00:00","value":80,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"system"},"timestamp":"2025-01-10T10:04:00+00:00","value":120,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:00:00+00:00","value":300,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:02:00+00:00","value":500,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"idle"},"timestamp":"2025-01-10T10:04:00+00:00","value":700,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:00:00+00:00","value":5,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:02:00+00:00","value":10,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.cpu.time","labels":{"host.name":"acc-h2","os.type":"linux","state":"wait"},"timestamp":"2025-01-10T10:04:00+00:00","value":15,"temporality":"Cumulative","type_":"Sum","is_monotonic":true}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":2100000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":2200000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":6000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":5900000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":5800000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"buffered"},"timestamp":"2025-01-10T10:00:00+00:00","value":500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"buffered"},"timestamp":"2025-01-10T10:02:00+00:00","value":500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"buffered"},"timestamp":"2025-01-10T10:04:00+00:00","value":500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"cached"},"timestamp":"2025-01-10T10:00:00+00:00","value":1500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"cached"},"timestamp":"2025-01-10T10:02:00+00:00","value":1500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"cached"},"timestamp":"2025-01-10T10:04:00+00:00","value":1500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":3000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":3250000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":3500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":5000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":4750000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":4500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"buffered"},"timestamp":"2025-01-10T10:00:00+00:00","value":500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"buffered"},"timestamp":"2025-01-10T10:02:00+00:00","value":500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"buffered"},"timestamp":"2025-01-10T10:04:00+00:00","value":500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"cached"},"timestamp":"2025-01-10T10:00:00+00:00","value":1500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"cached"},"timestamp":"2025-01-10T10:02:00+00:00","value":1500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.memory.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"cached"},"timestamp":"2025-01-10T10:04:00+00:00","value":1500000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"acc-h1","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"acc-h1","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.55,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"acc-h1","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"acc-h2","os.type":"linux"},"timestamp":"2025-01-10T10:00:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"acc-h2","os.type":"linux"},"timestamp":"2025-01-10T10:02:00+00:00","value":2.05,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.cpu.load_average.15m","labels":{"host.name":"acc-h2","os.type":"linux"},"timestamp":"2025-01-10T10:04:00+00:00","value":2.1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":51000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":52000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":50000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":49000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":48000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"reserved"},"timestamp":"2025-01-10T10:00:00+00:00","value":5000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"reserved"},"timestamp":"2025-01-10T10:02:00+00:00","value":5000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h1","os.type":"linux","state":"reserved"},"timestamp":"2025-01-10T10:04:00+00:00","value":5000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:00:00+00:00","value":70000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:02:00+00:00","value":71000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"used"},"timestamp":"2025-01-10T10:04:00+00:00","value":72000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:00:00+00:00","value":30000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:02:00+00:00","value":29000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"free"},"timestamp":"2025-01-10T10:04:00+00:00","value":28000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"reserved"},"timestamp":"2025-01-10T10:00:00+00:00","value":5000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"reserved"},"timestamp":"2025-01-10T10:02:00+00:00","value":5000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}
+{"metric_name":"system.filesystem.usage","labels":{"host.name":"acc-h2","os.type":"linux","state":"reserved"},"timestamp":"2025-01-10T10:04:00+00:00","value":5000000000,"temporality":"Unspecified","type_":"Sum","is_monotonic":false}

tests/integration/testdata/inframonitoring/hosts_value_accuracy_expected.json

@@ -0,0 +1,20 @@
+{
+  "records": [
+    {
+      "hostName": "acc-h1",
+      "cpu": 0.4444444444444445,
+      "memory": 0.205,
+      "wait": 0.027777777777777776,
+      "load15": 1.525,
+      "diskUsage": 0.48095238095238096
+    },
+    {
+      "hostName": "acc-h2",
+      "cpu": 0.3846153846153845,
+      "memory": 0.3125,
+      "wait": 0.015384615384615384,
+      "load15": 2.025,
+      "diskUsage": 0.6714285714285714
+    }
+  ]
+}

tests/integration/testdata/inframonitoring/namespaces_filter_dataset.jsonl

@@ -0,0 +1,144 @@
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1a-uid", "k8s.pod.name": "web-a-prod-acc-p1a", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1a-uid", "k8s.pod.name": "web-a-prod-acc-p1a", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1a-uid", "k8s.pod.name": "web-a-prod-acc-p1a", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1a-uid", "k8s.pod.name": "web-a-prod-acc-p1a", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1a-uid", "k8s.pod.name": "web-a-prod-acc-p1a", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1a-uid", "k8s.pod.name": "web-a-prod-acc-p1a", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1a-uid", "k8s.pod.name": "web-a-prod-acc-p1a", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "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-a-prod-acc-p1a-uid", "k8s.pod.name": "web-a-prod-acc-p1a", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "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-a-prod-acc-p1a-uid", "k8s.pod.name": "web-a-prod-acc-p1a", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1b-uid", "k8s.pod.name": "web-a-prod-acc-p1b", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1b-uid", "k8s.pod.name": "web-a-prod-acc-p1b", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1b-uid", "k8s.pod.name": "web-a-prod-acc-p1b", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1b-uid", "k8s.pod.name": "web-a-prod-acc-p1b", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1b-uid", "k8s.pod.name": "web-a-prod-acc-p1b", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1b-uid", "k8s.pod.name": "web-a-prod-acc-p1b", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-a-prod-acc-p1b-uid", "k8s.pod.name": "web-a-prod-acc-p1b", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "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-a-prod-acc-p1b-uid", "k8s.pod.name": "web-a-prod-acc-p1b", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "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-a-prod-acc-p1b-uid", "k8s.pod.name": "web-a-prod-acc-p1b", "k8s.namespace.name": "web-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1a-uid", "k8s.pod.name": "web-a-dev-acc-p1a", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1a-uid", "k8s.pod.name": "web-a-dev-acc-p1a", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1a-uid", "k8s.pod.name": "web-a-dev-acc-p1a", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1a-uid", "k8s.pod.name": "web-a-dev-acc-p1a", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1a-uid", "k8s.pod.name": "web-a-dev-acc-p1a", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1a-uid", "k8s.pod.name": "web-a-dev-acc-p1a", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1a-uid", "k8s.pod.name": "web-a-dev-acc-p1a", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "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-a-dev-acc-p1a-uid", "k8s.pod.name": "web-a-dev-acc-p1a", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "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-a-dev-acc-p1a-uid", "k8s.pod.name": "web-a-dev-acc-p1a", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1b-uid", "k8s.pod.name": "web-a-dev-acc-p1b", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1b-uid", "k8s.pod.name": "web-a-dev-acc-p1b", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1b-uid", "k8s.pod.name": "web-a-dev-acc-p1b", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1b-uid", "k8s.pod.name": "web-a-dev-acc-p1b", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1b-uid", "k8s.pod.name": "web-a-dev-acc-p1b", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1b-uid", "k8s.pod.name": "web-a-dev-acc-p1b", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-a-dev-acc-p1b-uid", "k8s.pod.name": "web-a-dev-acc-p1b", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "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-a-dev-acc-p1b-uid", "k8s.pod.name": "web-a-dev-acc-p1b", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "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-a-dev-acc-p1b-uid", "k8s.pod.name": "web-a-dev-acc-p1b", "k8s.namespace.name": "web-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1a-uid", "k8s.pod.name": "api-a-prod-acc-p1a", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1a-uid", "k8s.pod.name": "api-a-prod-acc-p1a", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1a-uid", "k8s.pod.name": "api-a-prod-acc-p1a", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1a-uid", "k8s.pod.name": "api-a-prod-acc-p1a", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1a-uid", "k8s.pod.name": "api-a-prod-acc-p1a", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1a-uid", "k8s.pod.name": "api-a-prod-acc-p1a", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1a-uid", "k8s.pod.name": "api-a-prod-acc-p1a", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "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-a-prod-acc-p1a-uid", "k8s.pod.name": "api-a-prod-acc-p1a", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "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-a-prod-acc-p1a-uid", "k8s.pod.name": "api-a-prod-acc-p1a", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1b-uid", "k8s.pod.name": "api-a-prod-acc-p1b", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1b-uid", "k8s.pod.name": "api-a-prod-acc-p1b", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1b-uid", "k8s.pod.name": "api-a-prod-acc-p1b", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1b-uid", "k8s.pod.name": "api-a-prod-acc-p1b", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1b-uid", "k8s.pod.name": "api-a-prod-acc-p1b", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1b-uid", "k8s.pod.name": "api-a-prod-acc-p1b", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-a-prod-acc-p1b-uid", "k8s.pod.name": "api-a-prod-acc-p1b", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "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-a-prod-acc-p1b-uid", "k8s.pod.name": "api-a-prod-acc-p1b", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "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-a-prod-acc-p1b-uid", "k8s.pod.name": "api-a-prod-acc-p1b", "k8s.namespace.name": "api-a-prod", "k8s.cluster.name": "cluster-a", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1a-uid", "k8s.pod.name": "api-a-dev-acc-p1a", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1a-uid", "k8s.pod.name": "api-a-dev-acc-p1a", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1a-uid", "k8s.pod.name": "api-a-dev-acc-p1a", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1a-uid", "k8s.pod.name": "api-a-dev-acc-p1a", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1a-uid", "k8s.pod.name": "api-a-dev-acc-p1a", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1a-uid", "k8s.pod.name": "api-a-dev-acc-p1a", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1a-uid", "k8s.pod.name": "api-a-dev-acc-p1a", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "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-a-dev-acc-p1a-uid", "k8s.pod.name": "api-a-dev-acc-p1a", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "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-a-dev-acc-p1a-uid", "k8s.pod.name": "api-a-dev-acc-p1a", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1b-uid", "k8s.pod.name": "api-a-dev-acc-p1b", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1b-uid", "k8s.pod.name": "api-a-dev-acc-p1b", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1b-uid", "k8s.pod.name": "api-a-dev-acc-p1b", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1b-uid", "k8s.pod.name": "api-a-dev-acc-p1b", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1b-uid", "k8s.pod.name": "api-a-dev-acc-p1b", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1b-uid", "k8s.pod.name": "api-a-dev-acc-p1b", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-a-dev-acc-p1b-uid", "k8s.pod.name": "api-a-dev-acc-p1b", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "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-a-dev-acc-p1b-uid", "k8s.pod.name": "api-a-dev-acc-p1b", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "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-a-dev-acc-p1b-uid", "k8s.pod.name": "api-a-dev-acc-p1b", "k8s.namespace.name": "api-a-dev", "k8s.cluster.name": "cluster-a", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1a-uid", "k8s.pod.name": "web-b-prod-acc-p1a", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1a-uid", "k8s.pod.name": "web-b-prod-acc-p1a", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1a-uid", "k8s.pod.name": "web-b-prod-acc-p1a", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1a-uid", "k8s.pod.name": "web-b-prod-acc-p1a", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1a-uid", "k8s.pod.name": "web-b-prod-acc-p1a", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1a-uid", "k8s.pod.name": "web-b-prod-acc-p1a", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1a-uid", "k8s.pod.name": "web-b-prod-acc-p1a", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "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-b-prod-acc-p1a-uid", "k8s.pod.name": "web-b-prod-acc-p1a", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "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-b-prod-acc-p1a-uid", "k8s.pod.name": "web-b-prod-acc-p1a", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1b-uid", "k8s.pod.name": "web-b-prod-acc-p1b", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1b-uid", "k8s.pod.name": "web-b-prod-acc-p1b", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1b-uid", "k8s.pod.name": "web-b-prod-acc-p1b", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1b-uid", "k8s.pod.name": "web-b-prod-acc-p1b", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1b-uid", "k8s.pod.name": "web-b-prod-acc-p1b", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1b-uid", "k8s.pod.name": "web-b-prod-acc-p1b", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-b-prod-acc-p1b-uid", "k8s.pod.name": "web-b-prod-acc-p1b", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "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-b-prod-acc-p1b-uid", "k8s.pod.name": "web-b-prod-acc-p1b", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "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-b-prod-acc-p1b-uid", "k8s.pod.name": "web-b-prod-acc-p1b", "k8s.namespace.name": "web-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1a-uid", "k8s.pod.name": "web-b-dev-acc-p1a", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1a-uid", "k8s.pod.name": "web-b-dev-acc-p1a", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1a-uid", "k8s.pod.name": "web-b-dev-acc-p1a", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1a-uid", "k8s.pod.name": "web-b-dev-acc-p1a", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1a-uid", "k8s.pod.name": "web-b-dev-acc-p1a", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1a-uid", "k8s.pod.name": "web-b-dev-acc-p1a", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1a-uid", "k8s.pod.name": "web-b-dev-acc-p1a", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "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-b-dev-acc-p1a-uid", "k8s.pod.name": "web-b-dev-acc-p1a", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "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-b-dev-acc-p1a-uid", "k8s.pod.name": "web-b-dev-acc-p1a", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1b-uid", "k8s.pod.name": "web-b-dev-acc-p1b", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1b-uid", "k8s.pod.name": "web-b-dev-acc-p1b", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1b-uid", "k8s.pod.name": "web-b-dev-acc-p1b", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1b-uid", "k8s.pod.name": "web-b-dev-acc-p1b", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1b-uid", "k8s.pod.name": "web-b-dev-acc-p1b", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1b-uid", "k8s.pod.name": "web-b-dev-acc-p1b", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "web-b-dev-acc-p1b-uid", "k8s.pod.name": "web-b-dev-acc-p1b", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "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-b-dev-acc-p1b-uid", "k8s.pod.name": "web-b-dev-acc-p1b", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "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-b-dev-acc-p1b-uid", "k8s.pod.name": "web-b-dev-acc-p1b", "k8s.namespace.name": "web-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1a-uid", "k8s.pod.name": "api-b-prod-acc-p1a", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1a-uid", "k8s.pod.name": "api-b-prod-acc-p1a", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1a-uid", "k8s.pod.name": "api-b-prod-acc-p1a", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1a-uid", "k8s.pod.name": "api-b-prod-acc-p1a", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1a-uid", "k8s.pod.name": "api-b-prod-acc-p1a", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1a-uid", "k8s.pod.name": "api-b-prod-acc-p1a", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1a-uid", "k8s.pod.name": "api-b-prod-acc-p1a", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "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-b-prod-acc-p1a-uid", "k8s.pod.name": "api-b-prod-acc-p1a", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "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-b-prod-acc-p1a-uid", "k8s.pod.name": "api-b-prod-acc-p1a", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1b-uid", "k8s.pod.name": "api-b-prod-acc-p1b", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1b-uid", "k8s.pod.name": "api-b-prod-acc-p1b", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1b-uid", "k8s.pod.name": "api-b-prod-acc-p1b", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1b-uid", "k8s.pod.name": "api-b-prod-acc-p1b", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1b-uid", "k8s.pod.name": "api-b-prod-acc-p1b", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1b-uid", "k8s.pod.name": "api-b-prod-acc-p1b", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-b-prod-acc-p1b-uid", "k8s.pod.name": "api-b-prod-acc-p1b", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "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-b-prod-acc-p1b-uid", "k8s.pod.name": "api-b-prod-acc-p1b", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "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-b-prod-acc-p1b-uid", "k8s.pod.name": "api-b-prod-acc-p1b", "k8s.namespace.name": "api-b-prod", "k8s.cluster.name": "cluster-b", "env": "prod"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1a-uid", "k8s.pod.name": "api-b-dev-acc-p1a", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1a-uid", "k8s.pod.name": "api-b-dev-acc-p1a", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1a-uid", "k8s.pod.name": "api-b-dev-acc-p1a", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1a-uid", "k8s.pod.name": "api-b-dev-acc-p1a", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1a-uid", "k8s.pod.name": "api-b-dev-acc-p1a", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1a-uid", "k8s.pod.name": "api-b-dev-acc-p1a", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1a-uid", "k8s.pod.name": "api-b-dev-acc-p1a", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "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-b-dev-acc-p1a-uid", "k8s.pod.name": "api-b-dev-acc-p1a", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "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-b-dev-acc-p1a-uid", "k8s.pod.name": "api-b-dev-acc-p1a", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1b-uid", "k8s.pod.name": "api-b-dev-acc-p1b", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1b-uid", "k8s.pod.name": "api-b-dev-acc-p1b", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1b-uid", "k8s.pod.name": "api-b-dev-acc-p1b", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1b-uid", "k8s.pod.name": "api-b-dev-acc-p1b", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1b-uid", "k8s.pod.name": "api-b-dev-acc-p1b", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1b-uid", "k8s.pod.name": "api-b-dev-acc-p1b", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 100000000.0, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "api-b-dev-acc-p1b-uid", "k8s.pod.name": "api-b-dev-acc-p1b", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "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-b-dev-acc-p1b-uid", "k8s.pod.name": "api-b-dev-acc-p1b", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "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-b-dev-acc-p1b-uid", "k8s.pod.name": "api-b-dev-acc-p1b", "k8s.namespace.name": "api-b-dev", "k8s.cluster.name": "cluster-b", "env": "dev"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}

tests/integration/testdata/inframonitoring/namespaces_groupby.jsonl

@@ -0,0 +1,36 @@
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-1-uid","k8s.pod.name":"pod-gb-ns-1","k8s.namespace.name":"gb-ns-1","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-1-uid","k8s.pod.name":"pod-gb-ns-1","k8s.namespace.name":"gb-ns-1","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-1-uid","k8s.pod.name":"pod-gb-ns-1","k8s.namespace.name":"gb-ns-1","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-1-uid","k8s.pod.name":"pod-gb-ns-1","k8s.namespace.name":"gb-ns-1","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-1-uid","k8s.pod.name":"pod-gb-ns-1","k8s.namespace.name":"gb-ns-1","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-1-uid","k8s.pod.name":"pod-gb-ns-1","k8s.namespace.name":"gb-ns-1","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-gb-ns-1-uid","k8s.pod.name":"pod-gb-ns-1","k8s.namespace.name":"gb-ns-1","k8s.cluster.name":"gb-cluster-a"},"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-ns-1-uid","k8s.pod.name":"pod-gb-ns-1","k8s.namespace.name":"gb-ns-1","k8s.cluster.name":"gb-cluster-a"},"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-ns-1-uid","k8s.pod.name":"pod-gb-ns-1","k8s.namespace.name":"gb-ns-1","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-2-uid","k8s.pod.name":"pod-gb-ns-2","k8s.namespace.name":"gb-ns-2","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-2-uid","k8s.pod.name":"pod-gb-ns-2","k8s.namespace.name":"gb-ns-2","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-2-uid","k8s.pod.name":"pod-gb-ns-2","k8s.namespace.name":"gb-ns-2","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-2-uid","k8s.pod.name":"pod-gb-ns-2","k8s.namespace.name":"gb-ns-2","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-2-uid","k8s.pod.name":"pod-gb-ns-2","k8s.namespace.name":"gb-ns-2","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-2-uid","k8s.pod.name":"pod-gb-ns-2","k8s.namespace.name":"gb-ns-2","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-gb-ns-2-uid","k8s.pod.name":"pod-gb-ns-2","k8s.namespace.name":"gb-ns-2","k8s.cluster.name":"gb-cluster-a"},"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-ns-2-uid","k8s.pod.name":"pod-gb-ns-2","k8s.namespace.name":"gb-ns-2","k8s.cluster.name":"gb-cluster-a"},"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-ns-2-uid","k8s.pod.name":"pod-gb-ns-2","k8s.namespace.name":"gb-ns-2","k8s.cluster.name":"gb-cluster-a"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-3-uid","k8s.pod.name":"pod-gb-ns-3","k8s.namespace.name":"gb-ns-3","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-3-uid","k8s.pod.name":"pod-gb-ns-3","k8s.namespace.name":"gb-ns-3","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-3-uid","k8s.pod.name":"pod-gb-ns-3","k8s.namespace.name":"gb-ns-3","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-3-uid","k8s.pod.name":"pod-gb-ns-3","k8s.namespace.name":"gb-ns-3","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-3-uid","k8s.pod.name":"pod-gb-ns-3","k8s.namespace.name":"gb-ns-3","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-3-uid","k8s.pod.name":"pod-gb-ns-3","k8s.namespace.name":"gb-ns-3","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-gb-ns-3-uid","k8s.pod.name":"pod-gb-ns-3","k8s.namespace.name":"gb-ns-3","k8s.cluster.name":"gb-cluster-b"},"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-ns-3-uid","k8s.pod.name":"pod-gb-ns-3","k8s.namespace.name":"gb-ns-3","k8s.cluster.name":"gb-cluster-b"},"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-ns-3-uid","k8s.pod.name":"pod-gb-ns-3","k8s.namespace.name":"gb-ns-3","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-4-uid","k8s.pod.name":"pod-gb-ns-4","k8s.namespace.name":"gb-ns-4","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-4-uid","k8s.pod.name":"pod-gb-ns-4","k8s.namespace.name":"gb-ns-4","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-gb-ns-4-uid","k8s.pod.name":"pod-gb-ns-4","k8s.namespace.name":"gb-ns-4","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-4-uid","k8s.pod.name":"pod-gb-ns-4","k8s.namespace.name":"gb-ns-4","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-4-uid","k8s.pod.name":"pod-gb-ns-4","k8s.namespace.name":"gb-ns-4","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-gb-ns-4-uid","k8s.pod.name":"pod-gb-ns-4","k8s.namespace.name":"gb-ns-4","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-gb-ns-4-uid","k8s.pod.name":"pod-gb-ns-4","k8s.namespace.name":"gb-ns-4","k8s.cluster.name":"gb-cluster-b"},"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-ns-4-uid","k8s.pod.name":"pod-gb-ns-4","k8s.namespace.name":"gb-ns-4","k8s.cluster.name":"gb-cluster-b"},"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-ns-4-uid","k8s.pod.name":"pod-gb-ns-4","k8s.namespace.name":"gb-ns-4","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/namespaces_missing_metrics.jsonl

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

tests/integration/testdata/inframonitoring/namespaces_orderby.jsonl

@@ -0,0 +1,45 @@
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-1-uid","k8s.pod.name":"pod-order-ns-1","k8s.namespace.name":"order-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-1-uid","k8s.pod.name":"pod-order-ns-1","k8s.namespace.name":"order-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-1-uid","k8s.pod.name":"pod-order-ns-1","k8s.namespace.name":"order-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-1-uid","k8s.pod.name":"pod-order-ns-1","k8s.namespace.name":"order-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":500000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-1-uid","k8s.pod.name":"pod-order-ns-1","k8s.namespace.name":"order-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":500000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-1-uid","k8s.pod.name":"pod-order-ns-1","k8s.namespace.name":"order-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":500000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-1-uid","k8s.pod.name":"pod-order-ns-1","k8s.namespace.name":"order-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-1-uid","k8s.pod.name":"pod-order-ns-1","k8s.namespace.name":"order-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-1-uid","k8s.pod.name":"pod-order-ns-1","k8s.namespace.name":"order-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-2-uid","k8s.pod.name":"pod-order-ns-2","k8s.namespace.name":"order-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-2-uid","k8s.pod.name":"pod-order-ns-2","k8s.namespace.name":"order-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-2-uid","k8s.pod.name":"pod-order-ns-2","k8s.namespace.name":"order-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-2-uid","k8s.pod.name":"pod-order-ns-2","k8s.namespace.name":"order-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":400000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-2-uid","k8s.pod.name":"pod-order-ns-2","k8s.namespace.name":"order-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":400000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-2-uid","k8s.pod.name":"pod-order-ns-2","k8s.namespace.name":"order-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":400000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-2-uid","k8s.pod.name":"pod-order-ns-2","k8s.namespace.name":"order-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-2-uid","k8s.pod.name":"pod-order-ns-2","k8s.namespace.name":"order-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-2-uid","k8s.pod.name":"pod-order-ns-2","k8s.namespace.name":"order-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-3-uid","k8s.pod.name":"pod-order-ns-3","k8s.namespace.name":"order-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-3-uid","k8s.pod.name":"pod-order-ns-3","k8s.namespace.name":"order-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-3-uid","k8s.pod.name":"pod-order-ns-3","k8s.namespace.name":"order-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-3-uid","k8s.pod.name":"pod-order-ns-3","k8s.namespace.name":"order-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":300000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-3-uid","k8s.pod.name":"pod-order-ns-3","k8s.namespace.name":"order-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":300000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-3-uid","k8s.pod.name":"pod-order-ns-3","k8s.namespace.name":"order-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":300000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-3-uid","k8s.pod.name":"pod-order-ns-3","k8s.namespace.name":"order-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-3-uid","k8s.pod.name":"pod-order-ns-3","k8s.namespace.name":"order-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-3-uid","k8s.pod.name":"pod-order-ns-3","k8s.namespace.name":"order-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-4-uid","k8s.pod.name":"pod-order-ns-4","k8s.namespace.name":"order-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-4-uid","k8s.pod.name":"pod-order-ns-4","k8s.namespace.name":"order-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-4-uid","k8s.pod.name":"pod-order-ns-4","k8s.namespace.name":"order-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-4-uid","k8s.pod.name":"pod-order-ns-4","k8s.namespace.name":"order-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-4-uid","k8s.pod.name":"pod-order-ns-4","k8s.namespace.name":"order-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-4-uid","k8s.pod.name":"pod-order-ns-4","k8s.namespace.name":"order-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-4-uid","k8s.pod.name":"pod-order-ns-4","k8s.namespace.name":"order-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-4-uid","k8s.pod.name":"pod-order-ns-4","k8s.namespace.name":"order-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-4-uid","k8s.pod.name":"pod-order-ns-4","k8s.namespace.name":"order-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-5-uid","k8s.pod.name":"pod-order-ns-5","k8s.namespace.name":"order-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-5-uid","k8s.pod.name":"pod-order-ns-5","k8s.namespace.name":"order-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-order-ns-5-uid","k8s.pod.name":"pod-order-ns-5","k8s.namespace.name":"order-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-5-uid","k8s.pod.name":"pod-order-ns-5","k8s.namespace.name":"order-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-5-uid","k8s.pod.name":"pod-order-ns-5","k8s.namespace.name":"order-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-order-ns-5-uid","k8s.pod.name":"pod-order-ns-5","k8s.namespace.name":"order-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-5-uid","k8s.pod.name":"pod-order-ns-5","k8s.namespace.name":"order-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-5-uid","k8s.pod.name":"pod-order-ns-5","k8s.namespace.name":"order-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-order-ns-5-uid","k8s.pod.name":"pod-order-ns-5","k8s.namespace.name":"order-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/namespaces_pagination.jsonl

@@ -0,0 +1,63 @@
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-1-uid","k8s.pod.name":"pod-page-ns-1","k8s.namespace.name":"page-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":7.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-1-uid","k8s.pod.name":"pod-page-ns-1","k8s.namespace.name":"page-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":7.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-1-uid","k8s.pod.name":"pod-page-ns-1","k8s.namespace.name":"page-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":7.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-1-uid","k8s.pod.name":"pod-page-ns-1","k8s.namespace.name":"page-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-1-uid","k8s.pod.name":"pod-page-ns-1","k8s.namespace.name":"page-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-1-uid","k8s.pod.name":"pod-page-ns-1","k8s.namespace.name":"page-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-1-uid","k8s.pod.name":"pod-page-ns-1","k8s.namespace.name":"page-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-1-uid","k8s.pod.name":"pod-page-ns-1","k8s.namespace.name":"page-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-1-uid","k8s.pod.name":"pod-page-ns-1","k8s.namespace.name":"page-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-2-uid","k8s.pod.name":"pod-page-ns-2","k8s.namespace.name":"page-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":6.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-2-uid","k8s.pod.name":"pod-page-ns-2","k8s.namespace.name":"page-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":6.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-2-uid","k8s.pod.name":"pod-page-ns-2","k8s.namespace.name":"page-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":6.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-2-uid","k8s.pod.name":"pod-page-ns-2","k8s.namespace.name":"page-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-2-uid","k8s.pod.name":"pod-page-ns-2","k8s.namespace.name":"page-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-2-uid","k8s.pod.name":"pod-page-ns-2","k8s.namespace.name":"page-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-2-uid","k8s.pod.name":"pod-page-ns-2","k8s.namespace.name":"page-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-2-uid","k8s.pod.name":"pod-page-ns-2","k8s.namespace.name":"page-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-2-uid","k8s.pod.name":"pod-page-ns-2","k8s.namespace.name":"page-ns-2","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-3-uid","k8s.pod.name":"pod-page-ns-3","k8s.namespace.name":"page-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-3-uid","k8s.pod.name":"pod-page-ns-3","k8s.namespace.name":"page-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-3-uid","k8s.pod.name":"pod-page-ns-3","k8s.namespace.name":"page-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-3-uid","k8s.pod.name":"pod-page-ns-3","k8s.namespace.name":"page-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-3-uid","k8s.pod.name":"pod-page-ns-3","k8s.namespace.name":"page-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-3-uid","k8s.pod.name":"pod-page-ns-3","k8s.namespace.name":"page-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-3-uid","k8s.pod.name":"pod-page-ns-3","k8s.namespace.name":"page-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-3-uid","k8s.pod.name":"pod-page-ns-3","k8s.namespace.name":"page-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-3-uid","k8s.pod.name":"pod-page-ns-3","k8s.namespace.name":"page-ns-3","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-4-uid","k8s.pod.name":"pod-page-ns-4","k8s.namespace.name":"page-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-4-uid","k8s.pod.name":"pod-page-ns-4","k8s.namespace.name":"page-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-4-uid","k8s.pod.name":"pod-page-ns-4","k8s.namespace.name":"page-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-4-uid","k8s.pod.name":"pod-page-ns-4","k8s.namespace.name":"page-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-4-uid","k8s.pod.name":"pod-page-ns-4","k8s.namespace.name":"page-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-4-uid","k8s.pod.name":"pod-page-ns-4","k8s.namespace.name":"page-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-4-uid","k8s.pod.name":"pod-page-ns-4","k8s.namespace.name":"page-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-4-uid","k8s.pod.name":"pod-page-ns-4","k8s.namespace.name":"page-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-4-uid","k8s.pod.name":"pod-page-ns-4","k8s.namespace.name":"page-ns-4","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-5-uid","k8s.pod.name":"pod-page-ns-5","k8s.namespace.name":"page-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-5-uid","k8s.pod.name":"pod-page-ns-5","k8s.namespace.name":"page-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-5-uid","k8s.pod.name":"pod-page-ns-5","k8s.namespace.name":"page-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-5-uid","k8s.pod.name":"pod-page-ns-5","k8s.namespace.name":"page-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-5-uid","k8s.pod.name":"pod-page-ns-5","k8s.namespace.name":"page-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-5-uid","k8s.pod.name":"pod-page-ns-5","k8s.namespace.name":"page-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-5-uid","k8s.pod.name":"pod-page-ns-5","k8s.namespace.name":"page-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-5-uid","k8s.pod.name":"pod-page-ns-5","k8s.namespace.name":"page-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-5-uid","k8s.pod.name":"pod-page-ns-5","k8s.namespace.name":"page-ns-5","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-6-uid","k8s.pod.name":"pod-page-ns-6","k8s.namespace.name":"page-ns-6","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-6-uid","k8s.pod.name":"pod-page-ns-6","k8s.namespace.name":"page-ns-6","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-6-uid","k8s.pod.name":"pod-page-ns-6","k8s.namespace.name":"page-ns-6","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-6-uid","k8s.pod.name":"pod-page-ns-6","k8s.namespace.name":"page-ns-6","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-6-uid","k8s.pod.name":"pod-page-ns-6","k8s.namespace.name":"page-ns-6","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-6-uid","k8s.pod.name":"pod-page-ns-6","k8s.namespace.name":"page-ns-6","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-6-uid","k8s.pod.name":"pod-page-ns-6","k8s.namespace.name":"page-ns-6","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-6-uid","k8s.pod.name":"pod-page-ns-6","k8s.namespace.name":"page-ns-6","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-6-uid","k8s.pod.name":"pod-page-ns-6","k8s.namespace.name":"page-ns-6","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-7-uid","k8s.pod.name":"pod-page-ns-7","k8s.namespace.name":"page-ns-7","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-7-uid","k8s.pod.name":"pod-page-ns-7","k8s.namespace.name":"page-ns-7","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pod-page-ns-7-uid","k8s.pod.name":"pod-page-ns-7","k8s.namespace.name":"page-ns-7","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-7-uid","k8s.pod.name":"pod-page-ns-7","k8s.namespace.name":"page-ns-7","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-7-uid","k8s.pod.name":"pod-page-ns-7","k8s.namespace.name":"page-ns-7","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pod-page-ns-7-uid","k8s.pod.name":"pod-page-ns-7","k8s.namespace.name":"page-ns-7","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-7-uid","k8s.pod.name":"pod-page-ns-7","k8s.namespace.name":"page-ns-7","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-7-uid","k8s.pod.name":"pod-page-ns-7","k8s.namespace.name":"page-ns-7","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pod-page-ns-7-uid","k8s.pod.name":"pod-page-ns-7","k8s.namespace.name":"page-ns-7","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/namespaces_pod_phases.jsonl

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

tests/integration/testdata/inframonitoring/namespaces_value_accuracy.jsonl

@@ -0,0 +1,45 @@
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p1a-uid","k8s.pod.name":"acc-p1a","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p1a-uid","k8s.pod.name":"acc-p1a","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p1a-uid","k8s.pod.name":"acc-p1a","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p1a-uid","k8s.pod.name":"acc-p1a","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p1a-uid","k8s.pod.name":"acc-p1a","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p1a-uid","k8s.pod.name":"acc-p1a","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-p1a-uid","k8s.pod.name":"acc-p1a","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-p1a-uid","k8s.pod.name":"acc-p1a","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-p1a-uid","k8s.pod.name":"acc-p1a","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p1b-uid","k8s.pod.name":"acc-p1b","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p1b-uid","k8s.pod.name":"acc-p1b","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p1b-uid","k8s.pod.name":"acc-p1b","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p1b-uid","k8s.pod.name":"acc-p1b","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p1b-uid","k8s.pod.name":"acc-p1b","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p1b-uid","k8s.pod.name":"acc-p1b","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-p1b-uid","k8s.pod.name":"acc-p1b","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-p1b-uid","k8s.pod.name":"acc-p1b","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-p1b-uid","k8s.pod.name":"acc-p1b","k8s.namespace.name":"acc-ns-1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2a-uid","k8s.pod.name":"acc-p2a","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2a-uid","k8s.pod.name":"acc-p2a","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2a-uid","k8s.pod.name":"acc-p2a","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2a-uid","k8s.pod.name":"acc-p2a","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:00:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2a-uid","k8s.pod.name":"acc-p2a","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:02:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2a-uid","k8s.pod.name":"acc-p2a","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:04:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-p2a-uid","k8s.pod.name":"acc-p2a","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"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-p2a-uid","k8s.pod.name":"acc-p2a","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"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-p2a-uid","k8s.pod.name":"acc-p2a","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2b-uid","k8s.pod.name":"acc-p2b","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2b-uid","k8s.pod.name":"acc-p2b","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2b-uid","k8s.pod.name":"acc-p2b","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2b-uid","k8s.pod.name":"acc-p2b","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:00:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2b-uid","k8s.pod.name":"acc-p2b","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:02:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2b-uid","k8s.pod.name":"acc-p2b","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:04:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-p2b-uid","k8s.pod.name":"acc-p2b","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"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-p2b-uid","k8s.pod.name":"acc-p2b","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"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-p2b-uid","k8s.pod.name":"acc-p2b","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2c-uid","k8s.pod.name":"acc-p2c","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2c-uid","k8s.pod.name":"acc-p2c","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2c-uid","k8s.pod.name":"acc-p2c","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2c-uid","k8s.pod.name":"acc-p2c","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:00:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2c-uid","k8s.pod.name":"acc-p2c","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:02:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2c-uid","k8s.pod.name":"acc-p2c","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:04:00+00:00","value":200000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-p2c-uid","k8s.pod.name":"acc-p2c","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"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-p2c-uid","k8s.pod.name":"acc-p2c","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"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-p2c-uid","k8s.pod.name":"acc-p2c","k8s.namespace.name":"acc-ns-2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/namespaces_value_accuracy_expected.json

@@ -0,0 +1,16 @@
+{
+  "records": [
+    {
+      "namespaceName": "acc-ns-1",
+      "namespaceCPU": 1.0,
+      "namespaceMemory": 200000000.0,
+      "podCountsByPhase": {"pending": 0, "running": 2, "succeeded": 0, "failed": 0, "unknown": 0}
+    },
+    {
+      "namespaceName": "acc-ns-2",
+      "namespaceCPU": 2.25,
+      "namespaceMemory": 600000000.0,
+      "podCountsByPhase": {"pending": 0, "running": 3, "succeeded": 0, "failed": 0, "unknown": 0}
+    }
+  ]
+}

tests/integration/testdata/inframonitoring/nodes_conditions.jsonl

@@ -0,0 +1,33 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"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":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"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":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"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":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"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":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"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":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"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":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"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":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"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":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"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":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"ready-n","k8s.node.uid":"ready-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"notready-n","k8s.node.uid":"notready-n-uid","k8s.cluster.name":"cluster-x"},"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":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-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":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-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":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/nodes_conditions_grouped.jsonl

@@ -0,0 +1,54 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-1","k8s.node.uid":"g-r1-uid","k8s.cluster.name":"cluster-mixed"},"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-g-ready-1-uid","k8s.pod.name":"pod-g-ready-1","k8s.namespace.name":"ns-x","k8s.node.name":"g-ready-1","k8s.cluster.name":"cluster-mixed"},"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-g-ready-1-uid","k8s.pod.name":"pod-g-ready-1","k8s.namespace.name":"ns-x","k8s.node.name":"g-ready-1","k8s.cluster.name":"cluster-mixed"},"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-g-ready-1-uid","k8s.pod.name":"pod-g-ready-1","k8s.namespace.name":"ns-x","k8s.node.name":"g-ready-1","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-ready-2","k8s.node.uid":"g-r2-uid","k8s.cluster.name":"cluster-mixed"},"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-g-ready-2-uid","k8s.pod.name":"pod-g-ready-2","k8s.namespace.name":"ns-x","k8s.node.name":"g-ready-2","k8s.cluster.name":"cluster-mixed"},"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-g-ready-2-uid","k8s.pod.name":"pod-g-ready-2","k8s.namespace.name":"ns-x","k8s.node.name":"g-ready-2","k8s.cluster.name":"cluster-mixed"},"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-g-ready-2-uid","k8s.pod.name":"pod-g-ready-2","k8s.namespace.name":"ns-x","k8s.node.name":"g-ready-2","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"g-notready-1","k8s.node.uid":"g-nr1-uid","k8s.cluster.name":"cluster-mixed"},"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":"pod-g-notready-1-uid","k8s.pod.name":"pod-g-notready-1","k8s.namespace.name":"ns-x","k8s.node.name":"g-notready-1","k8s.cluster.name":"cluster-mixed"},"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-g-notready-1-uid","k8s.pod.name":"pod-g-notready-1","k8s.namespace.name":"ns-x","k8s.node.name":"g-notready-1","k8s.cluster.name":"cluster-mixed"},"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-g-notready-1-uid","k8s.pod.name":"pod-g-notready-1","k8s.namespace.name":"ns-x","k8s.node.name":"g-notready-1","k8s.cluster.name":"cluster-mixed"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/nodes_conditions_transition.jsonl

@@ -0,0 +1,18 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"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":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"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":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"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":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"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":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"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":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"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":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"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":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"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":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"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":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"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":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"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":"trans-n","k8s.node.uid":"trans-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-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":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-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":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/nodes_filter_dataset.jsonl

@@ -0,0 +1,144 @@
+{"metric_name": "k8s.node.cpu.usage", "labels": {"k8s.node.name": "web-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "web-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "web-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "web-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "web-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "web-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "web-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-w-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1-acc-pod-1a-uid", "k8s.pod.name": "web-a-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-a-us-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-w-aus-1-uid", "zone": "us"}, "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-a-us-1-acc-pod-1a-uid", "k8s.pod.name": "web-a-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-a-us-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-w-aus-1-uid", "zone": "us"}, "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-a-us-1-acc-pod-1a-uid", "k8s.pod.name": "web-a-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-a-us-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-w-aus-1-uid", "zone": "us"}, "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-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "web-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "web-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "web-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "web-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "web-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "web-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-w-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1-acc-pod-1a-uid", "k8s.pod.name": "web-a-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-a-eu-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-w-aeu-1-uid", "zone": "eu"}, "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-a-eu-1-acc-pod-1a-uid", "k8s.pod.name": "web-a-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-a-eu-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-w-aeu-1-uid", "zone": "eu"}, "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-a-eu-1-acc-pod-1a-uid", "k8s.pod.name": "web-a-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-a-eu-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-w-aeu-1-uid", "zone": "eu"}, "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-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "api-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "api-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "api-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "api-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "api-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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": "api-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1", "k8s.node.uid": "f-a-aus-1-uid", "k8s.cluster.name": "cluster-a", "zone": "us"}, "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-a-us-1-acc-pod-1a-uid", "k8s.pod.name": "api-a-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-a-us-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-a-aus-1-uid", "zone": "us"}, "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-a-us-1-acc-pod-1a-uid", "k8s.pod.name": "api-a-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-a-us-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-a-aus-1-uid", "zone": "us"}, "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-a-us-1-acc-pod-1a-uid", "k8s.pod.name": "api-a-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-a-us-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-a-aus-1-uid", "zone": "us"}, "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-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "api-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "api-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "api-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "api-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "api-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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": "api-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1", "k8s.node.uid": "f-a-aeu-1-uid", "k8s.cluster.name": "cluster-a", "zone": "eu"}, "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-a-eu-1-acc-pod-1a-uid", "k8s.pod.name": "api-a-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-a-eu-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-a-aeu-1-uid", "zone": "eu"}, "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-a-eu-1-acc-pod-1a-uid", "k8s.pod.name": "api-a-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-a-eu-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-a-aeu-1-uid", "zone": "eu"}, "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-a-eu-1-acc-pod-1a-uid", "k8s.pod.name": "api-a-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-a-eu-1", "k8s.cluster.name": "cluster-a", "k8s.node.uid": "f-a-aeu-1-uid", "zone": "eu"}, "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-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "web-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "web-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "web-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "web-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "web-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "web-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-w-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1-acc-pod-1a-uid", "k8s.pod.name": "web-b-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-b-us-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-w-bus-1-uid", "zone": "us"}, "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-b-us-1-acc-pod-1a-uid", "k8s.pod.name": "web-b-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-b-us-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-w-bus-1-uid", "zone": "us"}, "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-b-us-1-acc-pod-1a-uid", "k8s.pod.name": "web-b-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-b-us-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-w-bus-1-uid", "zone": "us"}, "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-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "web-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "web-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "web-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "web-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "web-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "web-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-w-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1-acc-pod-1a-uid", "k8s.pod.name": "web-b-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-b-eu-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-w-beu-1-uid", "zone": "eu"}, "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-b-eu-1-acc-pod-1a-uid", "k8s.pod.name": "web-b-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-b-eu-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-w-beu-1-uid", "zone": "eu"}, "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-b-eu-1-acc-pod-1a-uid", "k8s.pod.name": "web-b-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "web-b-eu-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-w-beu-1-uid", "zone": "eu"}, "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-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "api-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "api-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "api-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "api-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "api-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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": "api-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1", "k8s.node.uid": "f-a-bus-1-uid", "k8s.cluster.name": "cluster-b", "zone": "us"}, "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-b-us-1-acc-pod-1a-uid", "k8s.pod.name": "api-b-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-b-us-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-a-bus-1-uid", "zone": "us"}, "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-b-us-1-acc-pod-1a-uid", "k8s.pod.name": "api-b-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-b-us-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-a-bus-1-uid", "zone": "us"}, "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-b-us-1-acc-pod-1a-uid", "k8s.pod.name": "api-b-us-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-b-us-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-a-bus-1-uid", "zone": "us"}, "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-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "api-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "api-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "api-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "api-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "api-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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": "api-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1", "k8s.node.uid": "f-a-beu-1-uid", "k8s.cluster.name": "cluster-b", "zone": "eu"}, "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-b-eu-1-acc-pod-1a-uid", "k8s.pod.name": "api-b-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-b-eu-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-a-beu-1-uid", "zone": "eu"}, "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-b-eu-1-acc-pod-1a-uid", "k8s.pod.name": "api-b-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-b-eu-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-a-beu-1-uid", "zone": "eu"}, "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-b-eu-1-acc-pod-1a-uid", "k8s.pod.name": "api-b-eu-1-acc-pod-1a", "k8s.namespace.name": "ns-a", "k8s.node.name": "api-b-eu-1", "k8s.cluster.name": "cluster-b", "k8s.node.uid": "f-a-beu-1-uid", "zone": "eu"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}

tests/integration/testdata/inframonitoring/nodes_groupby.jsonl

@@ -0,0 +1,72 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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":"gb-a-us","k8s.node.uid":"gb-aus-uid","k8s.cluster.name":"gb-cluster-a","zone":"us"},"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-a-us-uid","k8s.pod.name":"pod-gb-a-us","k8s.namespace.name":"ns-x","k8s.node.name":"gb-a-us","k8s.cluster.name":"gb-cluster-a"},"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-a-us-uid","k8s.pod.name":"pod-gb-a-us","k8s.namespace.name":"ns-x","k8s.node.name":"gb-a-us","k8s.cluster.name":"gb-cluster-a"},"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-a-us-uid","k8s.pod.name":"pod-gb-a-us","k8s.namespace.name":"ns-x","k8s.node.name":"gb-a-us","k8s.cluster.name":"gb-cluster-a"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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":"gb-a-eu","k8s.node.uid":"gb-aeu-uid","k8s.cluster.name":"gb-cluster-a","zone":"eu"},"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-a-eu-uid","k8s.pod.name":"pod-gb-a-eu","k8s.namespace.name":"ns-x","k8s.node.name":"gb-a-eu","k8s.cluster.name":"gb-cluster-a"},"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-a-eu-uid","k8s.pod.name":"pod-gb-a-eu","k8s.namespace.name":"ns-x","k8s.node.name":"gb-a-eu","k8s.cluster.name":"gb-cluster-a"},"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-a-eu-uid","k8s.pod.name":"pod-gb-a-eu","k8s.namespace.name":"ns-x","k8s.node.name":"gb-a-eu","k8s.cluster.name":"gb-cluster-a"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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":"gb-b-us","k8s.node.uid":"gb-bus-uid","k8s.cluster.name":"gb-cluster-b","zone":"us"},"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-b-us-uid","k8s.pod.name":"pod-gb-b-us","k8s.namespace.name":"ns-x","k8s.node.name":"gb-b-us","k8s.cluster.name":"gb-cluster-b"},"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-b-us-uid","k8s.pod.name":"pod-gb-b-us","k8s.namespace.name":"ns-x","k8s.node.name":"gb-b-us","k8s.cluster.name":"gb-cluster-b"},"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-b-us-uid","k8s.pod.name":"pod-gb-b-us","k8s.namespace.name":"ns-x","k8s.node.name":"gb-b-us","k8s.cluster.name":"gb-cluster-b"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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":"gb-b-eu","k8s.node.uid":"gb-beu-uid","k8s.cluster.name":"gb-cluster-b","zone":"eu"},"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-b-eu-uid","k8s.pod.name":"pod-gb-b-eu","k8s.namespace.name":"ns-x","k8s.node.name":"gb-b-eu","k8s.cluster.name":"gb-cluster-b"},"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-b-eu-uid","k8s.pod.name":"pod-gb-b-eu","k8s.namespace.name":"ns-x","k8s.node.name":"gb-b-eu","k8s.cluster.name":"gb-cluster-b"},"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-b-eu-uid","k8s.pod.name":"pod-gb-b-eu","k8s.namespace.name":"ns-x","k8s.node.name":"gb-b-eu","k8s.cluster.name":"gb-cluster-b"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/nodes_missing_metrics.jsonl

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

tests/integration/testdata/inframonitoring/nodes_no_pods.jsonl

@@ -0,0 +1,18 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_cpu","labels":{"k8s.node.name":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"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":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"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":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"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":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"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":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"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":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"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":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"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":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"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":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"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":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"no-pod-n","k8s.node.uid":"no-pod-n-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-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":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-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":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/nodes_orderby.jsonl

@@ -0,0 +1,78 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-n1","k8s.node.uid":"order-n1-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-n2","k8s.node.uid":"order-n2-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-n3","k8s.node.uid":"order-n3-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-n4","k8s.node.uid":"order-n4-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"order-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"order-n5","k8s.node.uid":"order-n5-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-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":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-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":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/nodes_pagination.jsonl

@@ -0,0 +1,108 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n1","k8s.node.uid":"page-n1-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"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-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n2","k8s.node.uid":"page-n2-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"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-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n3","k8s.node.uid":"page-n3-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"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-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n4","k8s.node.uid":"page-n4-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"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-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n5","k8s.node.uid":"page-n5-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"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-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n6","k8s.node.uid":"page-n6-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"page-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"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-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"page-n7","k8s.node.uid":"page-n7-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-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":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-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":"carrier-pod-uid","k8s.pod.name":"carrier-pod","k8s.namespace.name":"carrier-ns","k8s.node.name":"carrier-phantom-host","k8s.cluster.name":"carrier-cluster"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/nodes_pod_phases.jsonl

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

tests/integration/testdata/inframonitoring/nodes_value_accuracy.jsonl

@@ -0,0 +1,36 @@
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"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-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-n1","k8s.node.uid":"acc-n1-uid","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-pod-1a-uid","k8s.pod.name":"acc-pod-1a","k8s.namespace.name":"ns-a","k8s.node.name":"acc-n1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:00:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-pod-1a-uid","k8s.pod.name":"acc-pod-1a","k8s.namespace.name":"ns-a","k8s.node.name":"acc-n1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:02:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-pod-1a-uid","k8s.pod.name":"acc-pod-1a","k8s.namespace.name":"ns-a","k8s.node.name":"acc-n1","k8s.cluster.name":"cluster-x"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.cpu.usage","labels":{"k8s.node.name":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:00:00+00:00","value":32000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:02:00+00:00","value":32000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.allocatable_memory","labels":{"k8s.node.name":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:04:00+00:00","value":32000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.node.condition_ready","labels":{"k8s.node.name":"acc-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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-n2","k8s.node.uid":"acc-n2-uid","k8s.cluster.name":"cluster-y"},"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-pod-2a-uid","k8s.pod.name":"acc-pod-2a","k8s.namespace.name":"ns-b","k8s.node.name":"acc-n2","k8s.cluster.name":"cluster-y"},"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-pod-2a-uid","k8s.pod.name":"acc-pod-2a","k8s.namespace.name":"ns-b","k8s.node.name":"acc-n2","k8s.cluster.name":"cluster-y"},"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-pod-2a-uid","k8s.pod.name":"acc-pod-2a","k8s.namespace.name":"ns-b","k8s.node.name":"acc-n2","k8s.cluster.name":"cluster-y"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/nodes_value_accuracy_expected.json

@@ -0,0 +1,24 @@
+{
+  "records": [
+    {
+      "nodeName": "acc-n1",
+      "nodeCPU": 1.0,
+      "nodeCPUAllocatable": 4.0,
+      "nodeMemory": 2000000000.0,
+      "nodeMemoryAllocatable": 8000000000.0,
+      "condition": "ready",
+      "nodeCountsByReadiness": {"ready": 1, "notReady": 0},
+      "podCountsByPhase": {"pending": 0, "running": 1, "succeeded": 0, "failed": 0, "unknown": 0}
+    },
+    {
+      "nodeName": "acc-n2",
+      "nodeCPU": 3.0,
+      "nodeCPUAllocatable": 16.0,
+      "nodeMemory": 4000000000.0,
+      "nodeMemoryAllocatable": 32000000000.0,
+      "condition": "ready",
+      "nodeCountsByReadiness": {"ready": 1, "notReady": 0},
+      "podCountsByPhase": {"pending": 0, "running": 1, "succeeded": 0, "failed": 0, "unknown": 0}
+    }
+  ]
+}

tests/integration/testdata/inframonitoring/pods_filter_dataset.jsonl

@@ -0,0 +1,168 @@
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-web-prod-1-uid", "k8s.pod.name": "web-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-web-prod-2-uid", "k8s.pod.name": "web-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-api-prod-1-uid", "k8s.pod.name": "api-prod-1", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-api-prod-2-uid", "k8s.pod.name": "api-prod-2", "k8s.namespace.name": "ns-prod", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-web-dev-1-uid", "k8s.pod.name": "web-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-web-dev-2-uid", "k8s.pod.name": "web-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-a", "k8s.deployment.name": "web", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-api-dev-1-uid", "k8s.pod.name": "api-dev-1", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu.usage", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.cpu_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory.working_set", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 524288000, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_request_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.5, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:00:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:02:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.memory_limit_utilization", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 0.25, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}
+{"metric_name": "k8s.pod.phase", "labels": {"k8s.pod.uid": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "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": "fp-api-dev-2-uid", "k8s.pod.name": "api-dev-2", "k8s.namespace.name": "ns-dev", "k8s.node.name": "node-b", "k8s.deployment.name": "api", "k8s.cluster.name": "cluster-x", "k8s.statefulset.name": "", "k8s.daemonset.name": "", "k8s.job.name": "", "k8s.cronjob.name": "", "k8s.pod.start_time": "__START_TIME__"}, "timestamp": "2025-01-10T10:04:00+00:00", "value": 2, "temporality": "Unspecified", "type_": "Gauge", "is_monotonic": false}

tests/integration/testdata/inframonitoring/pods_groupby.jsonl

@@ -0,0 +1,84 @@
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-p1-uid","k8s.pod.name":"g-p1","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-p2-uid","k8s.pod.name":"g-p2","k8s.namespace.name":"gns-a","k8s.node.name":"node-a","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-p3-uid","k8s.pod.name":"g-p3","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-p4-uid","k8s.pod.name":"g-p4","k8s.namespace.name":"gns-b","k8s.node.name":"node-b","k8s.deployment.name":"gdep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/pods_missing_metrics.jsonl

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

tests/integration/testdata/inframonitoring/pods_orderby.jsonl

@@ -0,0 +1,105 @@
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.9,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.9,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.9,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":1000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.05,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.05,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.05,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"order-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p1-uid","k8s.pod.name":"order-p1","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.8,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.8,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.8,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"order-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p2-uid","k8s.pod.name":"order-p2","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.7,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.7,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.7,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":3000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":3000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":3000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.15,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.15,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.15,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"order-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p3-uid","k8s.pod.name":"order-p3","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.6,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":4000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":4000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":4000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"order-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p4-uid","k8s.pod.name":"order-p4","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":5000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":5000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":5000000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.25,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.25,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.25,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"order-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p5-uid","k8s.pod.name":"order-p5","k8s.namespace.name":"ns-order","k8s.node.name":"node-a","k8s.deployment.name":"order-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/pods_pagination.jsonl

@@ -0,0 +1,147 @@
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":7.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":7.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":7.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p1-uid","k8s.pod.name":"page-p1","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":6.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":6.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":6.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p2-uid","k8s.pod.name":"page-p2","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":5.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p3-uid","k8s.pod.name":"page-p3","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":4.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p4-uid","k8s.pod.name":"page-p4","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":3.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p5-uid","k8s.pod.name":"page-p5","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p6-uid","k8s.pod.name":"page-p6","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"page-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p7-uid","k8s.pod.name":"page-p7","k8s.namespace.name":"ns-page","k8s.node.name":"node-a","k8s.deployment.name":"page-dep","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/pods_phases.jsonl

@@ -0,0 +1,105 @@
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"pend-p-uid","k8s.pod.name":"pend-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"run-p-uid","k8s.pod.name":"run-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"succ-p-uid","k8s.pod.name":"succ-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":3,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"fail-p-uid","k8s.pod.name":"fail-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"unk-p-uid","k8s.pod.name":"unk-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/pods_phases_grouped.jsonl

@@ -0,0 +1,126 @@
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-run-1-uid","k8s.pod.name":"g-run-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-run-2-uid","k8s.pod.name":"g-run-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-run-3-uid","k8s.pod.name":"g-run-3","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-a","k8s.deployment.name":"dep-x","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-fail-1-uid","k8s.pod.name":"g-fail-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-fail-2-uid","k8s.pod.name":"g-fail-2","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":4,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"g-pend-1-uid","k8s.pod.name":"g-pend-1","k8s.namespace.name":"ns-mixed","k8s.node.name":"node-b","k8s.deployment.name":"dep-y","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":1,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/pods_phases_transition.jsonl

@@ -0,0 +1,21 @@
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":100000000.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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":"trans-p-uid","k8s.pod.name":"trans-p","k8s.namespace.name":"ns-x","k8s.node.name":"node-a","k8s.deployment.name":"phase-test","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/pods_value_accuracy.jsonl

@@ -0,0 +1,42 @@
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.25,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.25,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.25,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":524288000,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":524288000,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":524288000,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.25,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.25,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.25,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p1-uid","k8s.pod.name":"acc-p1","k8s.namespace.name":"ns-a","k8s.node.name":"node-a","k8s.deployment.name":"dep-1","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu.usage","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_request_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.cpu_limit_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":1.0,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":1073741824,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":1073741824,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory.working_set","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":1073741824,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_request_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.75,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:00:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:02:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.memory_limit_utilization","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":0.5,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}
+{"metric_name":"k8s.pod.phase","labels":{"k8s.pod.uid":"acc-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"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-p2-uid","k8s.pod.name":"acc-p2","k8s.namespace.name":"ns-b","k8s.node.name":"node-b","k8s.deployment.name":"dep-2","k8s.cluster.name":"cluster-x","k8s.statefulset.name":"","k8s.daemonset.name":"","k8s.job.name":"","k8s.cronjob.name":"","k8s.pod.start_time":"__START_TIME__"},"timestamp":"2025-01-10T10:04:00+00:00","value":2,"temporality":"Unspecified","type_":"Gauge","is_monotonic":false}

tests/integration/testdata/inframonitoring/pods_value_accuracy_expected.json

@@ -0,0 +1,26 @@
+{
+  "records": [
+    {
+      "podName": "acc-p1",
+      "podCPU": 0.5,
+      "podCPURequest": 0.25,
+      "podCPULimit": 0.5,
+      "podMemory": 524288000.0,
+      "podMemoryRequest": 0.5,
+      "podMemoryLimit": 0.25,
+      "podPhase": "running",
+      "podCountsByPhase": {"pending": 0, "running": 1, "succeeded": 0, "failed": 0, "unknown": 0}
+    },
+    {
+      "podName": "acc-p2",
+      "podCPU": 1.5,
+      "podCPURequest": 0.75,
+      "podCPULimit": 1.0,
+      "podMemory": 1073741824.0,
+      "podMemoryRequest": 0.75,
+      "podMemoryLimit": 0.5,
+      "podPhase": "running",
+      "podCountsByPhase": {"pending": 0, "running": 1, "succeeded": 0, "failed": 0, "unknown": 0}
+    }
+  ]
+}

tests/integration/tests/inframonitoring/01_hosts.py

@@ -0,0 +1,634 @@
+"""Integration tests for v2 infra-monitoring host 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/hosts"
+
+
+def test_hosts_accuracy(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Seed 2 hosts x 4 metrics; assert response shape/contract + exact metric
+    values per record against precomputed expected output."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/hosts_value_accuracy.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    with open(
+        get_testdata_file_path("inframonitoring/hosts_value_accuracy_expected.json"),
+        encoding="utf-8",
+    ) as f:
+        expected = json.load(f)
+    exp_by_host = {r["hostName"]: 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
+    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["hostName"] for r in data["records"]} == set(exp_by_host.keys())
+
+    for record in data["records"]:
+        for field in (
+            "hostName",
+            "status",
+            "cpu",
+            "memory",
+            "wait",
+            "load15",
+            "diskUsage",
+            "meta",
+        ):
+            assert field in record, f"missing {field} in {record!r}"
+
+        # Exact metric values.
+        exp = exp_by_host[record["hostName"]]
+        for field in ("cpu", "memory", "wait", "load15", "diskUsage"):
+            assert compare_values(record[field], exp[field], 1e-9), f"{record['hostName']}.{field}: got {record[field]}, expected {exp[field]}"
+
+
+def test_hosts_missing_metrics(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Seed only system.cpu.time; assert other 3 required metrics flagged missing."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/hosts_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
+    data = response.json()["data"]
+
+    assert set(data["requiredMetricsCheck"]["missingMetrics"]) == {
+        "system.memory.usage",
+        "system.cpu.load_average.15m",
+        "system.filesystem.usage",
+    }
+    # Endpoint short-circuits when any required metric is missing:
+    # records is empty and total=0 regardless of which hosts have partial data.
+    # See pkg/modules/inframonitoring/implinframonitoring/module.go:84-89.
+    assert data["records"] == []
+    assert data["total"] == 0
+
+
+@pytest.mark.parametrize(
+    "expression,expected_hosts",
+    [
+        pytest.param(
+            "host.name = 'prod-linux-1' AND os.type = 'linux'",
+            {"prod-linux-1"},
+            id="and",
+        ),
+        pytest.param(
+            "host.name IN ('prod-linux-1', 'prod-windows-1')",
+            {"prod-linux-1", "prod-windows-1"},
+            id="in",
+        ),
+        pytest.param(
+            "host.name NOT IN ('prod-linux-1', 'prod-windows-1')",
+            {"dev-linux-1", "dev-windows-1"},
+            id="not_in",
+        ),
+        pytest.param(
+            "host.name CONTAINS 'prod-'",
+            {"prod-linux-1", "prod-windows-1"},
+            id="contains",
+        ),
+        pytest.param(
+            "os.type = 'linux' AND host.name IN ('prod-linux-1', 'prod-windows-1')",
+            {"prod-linux-1"},
+            id="and_in",
+        ),
+        pytest.param(
+            "os.type = 'linux' AND host.name NOT IN ('prod-linux-1', 'prod-windows-1')",
+            {"dev-linux-1"},
+            id="and_not_in",
+        ),
+        pytest.param(
+            "os.type = 'linux' AND host.name CONTAINS 'prod-'",
+            {"prod-linux-1"},
+            id="and_contains",
+        ),
+        pytest.param(
+            "host.name IN ('prod-linux-1', 'prod-windows-1', 'dev-linux-1') AND host.name CONTAINS 'linux'",
+            {"prod-linux-1", "dev-linux-1"},
+            id="in_contains",
+        ),
+    ],
+)
+def test_hosts_filter(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    expression: str,
+    expected_hosts: set,
+) -> None:
+    """Filter operators (=, IN, NOT IN, CONTAINS) and their AND-combinations
+    return exactly the matching hosts, with undistorted per-host metric values."""
+    # Every host in hosts_filter_dataset.jsonl carries the same sample pattern
+    # as acc-h1 in hosts_value_accuracy.jsonl, so all filtered records must
+    # resolve to these exact values (mirrors hosts_value_accuracy_expected.json
+    # acc-h1).
+    expected_values = {
+        "cpu": 0.4444444444444445,
+        "memory": 0.205,
+        "wait": 0.027777777777777776,
+        "load15": 1.525,
+        "diskUsage": 0.48095238095238096,
+    }
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/hosts_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
+    data = response.json()["data"]
+    assert {r["hostName"] for r in data["records"]} == expected_hosts
+    assert data["total"] == len(expected_hosts)
+
+    # Filtering must not distort per-host aggregation values.
+    for record in data["records"]:
+        for field in ("cpu", "memory", "wait", "load15", "diskUsage"):
+            assert compare_values(record[field], expected_values[field], 1e-9), f"{record['hostName']}.{field}: got {record[field]}, expected {expected_values[field]}"
+
+
+@pytest.mark.parametrize(
+    "expression,err_substr",
+    [
+        pytest.param("host.namee = 'prod-linux-1'", "host.namee", id="bad_attr_name"),
+        pytest.param("host.name =", None, id="trailing_op"),
+        pytest.param("(host.name = 'prod-linux-1'", None, id="unclosed_paren"),
+        # Cases dropped — parser is permissive and accepts these silently:
+        #   `host.name == 'x'` → treated as `=` (matches as if single `=`)
+        #   `host.name 'x'`    → returns 200 with empty records
+        # Tracked as a QB v5 parser gap; not enforced by this test.
+    ],
+)
+def test_hosts_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/hosts_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}"
+
+
+@pytest.mark.parametrize(
+    "status,expected_hosts",
+    [
+        pytest.param("active", {"active-h1"}, id="active"),
+        pytest.param("inactive", {"inactive-h1"}, id="inactive"),
+        pytest.param(None, {"active-h1", "inactive-h1"}, id="unset"),
+    ],
+)
+def test_hosts_filter_by_status(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    status,
+    expected_hosts: set,
+) -> None:
+    """filterByStatus subsets hosts and per-record activeHostCount/inactiveHostCount
+    track each host's status. Omitting filterByStatus returns all hosts.
+    """
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/hosts_status.jsonl"),
+            base_time=now - timedelta(minutes=24),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    body = {
+        "start": int((now - timedelta(minutes=30)).timestamp() * 1000),
+        "end": int(now.timestamp() * 1000),
+        "limit": 50,
+    }
+    if status is not None:
+        body["filter"] = {"filterByStatus": status}
+
+    response = requests.post(
+        signoz.self.host_configs["8080"].get(ENDPOINT),
+        headers={"authorization": f"Bearer {token}"},
+        json=body,
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK
+    data = response.json()["data"]
+
+    assert {r["hostName"] for r in data["records"]} == expected_hosts
+    assert data["total"] == len(expected_hosts)
+
+    if status is not None:
+        for r in data["records"]:
+            assert r["status"] == status
+
+    for r in data["records"]:
+        if r["status"] == "active":
+            assert r["activeHostCount"] == 1
+            assert r["inactiveHostCount"] == 0
+        else:
+            assert r["status"] == "inactive"
+            assert r["activeHostCount"] == 0
+            assert r["inactiveHostCount"] == 1
+
+
+@pytest.mark.parametrize(
+    "dataset,seed_age_min,window_min,group_key,expected_counts,expected_values",
+    [
+        # groupBy=[host.name]: one record per distinct host. Per-host status is
+        # not pinned by the dataset, so expected counts are None (assert
+        # active+inactive == 1 instead).
+        pytest.param(
+            "hosts_filter_dataset.jsonl",
+            4,
+            5,
+            "host.name",
+            {
+                "prod-linux-1": None,
+                "prod-windows-1": None,
+                "dev-linux-1": None,
+                "dev-windows-1": None,
+            },
+            None,
+            id="host_name",
+        ),
+        # groupBy=[os.type]: aggregates active/inactive counts and metric values
+        # per os.type. Seed had linux: 2 active + 1 inactive, windows: 1 active
+        # + 2 inactive. Aggregated metric values differ between groups because
+        # active hosts (last sample step-floored out) and inactive hosts (all 3
+        # samples averaged) contribute slightly different per-host
+        # contributions to the space-aggregated formula.
+        pytest.param(
+            "hosts_groupby_os_type.jsonl",
+            24,
+            30,
+            "os.type",
+            {"linux": (2, 1), "windows": (1, 2)},
+            {
+                "linux": {
+                    "cpu": 0.3333333333333333,
+                    "memory": 0.25892857142857145,
+                    "wait": 0,
+                    "load15": 2.15,
+                    "diskUsage": 0.5071428571428571,
+                },
+                "windows": {
+                    "cpu": 0.33333333333333337,
+                    "memory": 0.2609375,
+                    "wait": 0,
+                    "load15": 2.47,
+                    "diskUsage": 0.50875,
+                },
+            },
+            id="os_type",
+        ),
+    ],
+)
+def test_hosts_groupby(  # pylint: disable=too-many-arguments,too-many-positional-arguments
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    dataset: str,
+    seed_age_min: int,
+    window_min: int,
+    group_key: str,
+    expected_counts: dict,
+    expected_values: dict,
+) -> None:
+    """groupBy returns one record per distinct group with aggregated
+    active/inactive counts and metric values. hostName is populated only when
+    grouping by host.name (hosts.go:144-160 list-vs-grouped branches)."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path(f"inframonitoring/{dataset}"),
+            base_time=now - timedelta(minutes=seed_age_min),
+        )
+    )
+
+    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=window_min)).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
+    data = response.json()["data"]
+    assert data["total"] == len(expected_counts)
+
+    group_of = lambda r: r["hostName"] if group_key == "host.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_counts.keys())
+
+    for group, rec in by_group.items():
+        counts = expected_counts[group]
+        if counts is not None:
+            assert (rec["activeHostCount"], rec["inactiveHostCount"]) == counts, f"{group}: got ({rec['activeHostCount']}, {rec['inactiveHostCount']}), expected {counts}"
+        else:
+            assert rec["activeHostCount"] + rec["inactiveHostCount"] == 1
+
+        # hostName is populated per host when grouping by host.name, and empty
+        # when host.name is NOT in groupBy.
+        assert rec["hostName"] == (group if group_key == "host.name" else "")
+
+        if expected_values is not None:
+            for field in ("cpu", "memory", "wait", "load15", "diskUsage"):
+                assert compare_values(rec[field], expected_values[group][field], 1e-9), f"{group}.{field}: got {rec[field]}, expected {expected_values[group][field]}"
+
+
+def test_hosts_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/hosts_pagination.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    K, limit = 7, 3
+    seen_hosts: 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,
+            },
+            timeout=5,
+        )
+        assert response.status_code == HTTPStatus.OK
+        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} records, got {len(data['records'])}"
+        seen_hosts.extend(r["hostName"] for r in data["records"])
+
+    assert seen_totals == {K}
+    assert len(seen_hosts) == K
+    assert set(seen_hosts) == {f"page-h{i}" for i in range(1, K + 1)}
+
+
+# orderBy keys use snake_case (inframonitoringtypes/hosts_constants.go:26-30).
+# Note: response uses camelCase (diskUsage) but request uses disk_usage.
+# host.name sorts via the metadata-name branch (hosts.go:218-219,
+# PaginateMetadataByName) and is only allowed when groupBy is empty.
+@pytest.mark.parametrize(
+    "column,record_field",
+    [
+        pytest.param("cpu", "cpu", id="cpu"),
+        pytest.param("memory", "memory", id="memory"),
+        pytest.param("wait", "wait", id="wait"),
+        pytest.param("load15", "load15", id="load15"),
+        pytest.param("disk_usage", "diskUsage", id="disk_usage"),
+        pytest.param("host.name", "hostName", id="host_name"),
+    ],
+)
+@pytest.mark.parametrize("direction", ["asc", "desc"])
+def test_hosts_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. Hosts have
+    staggered timestamps (simulating real-world emit drift)."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/hosts_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 hosts seeded by other tests in the shared backend.
+            "filter": {"expression": "host.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(
+            {"filter": {"filterByStatus": "bogus"}},
+            "invalid filter by status",
+            id="filter_by_status_invalid",
+        ),
+        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": "host.name"}, "direction": "desc"},
+                "groupBy": [
+                    {
+                        "name": "host.name",
+                        "fieldDataType": "string",
+                        "fieldContext": "resource",
+                    }
+                ],
+            },
+            "is only allowed when groupBy is empty",
+            id="orderby_hostname_with_groupby",
+        ),
+    ],
+)
+def test_hosts_validation_errors(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    payload_override: dict,
+    err_substr: str,
+) -> None:
+    """All PostableHosts.Validate() rules reject with 400 + descriptive error.
+    See pkg/types/inframonitoringtypes/hosts.go:53-108."""
+    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}"

tests/integration/tests/inframonitoring/02_pods.py

@@ -0,0 +1,760 @@
+"""Integration tests for v2 infra-monitoring pod 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
+from fixtures.time import parse_timestamp
+
+ENDPOINT = "/api/v2/infra_monitoring/pods"
+
+# Required metrics for the v2 pods endpoint
+# (pkg/modules/inframonitoring/implinframonitoring/pods_constants.go:24-32).
+REQUIRED_METRICS = {
+    "k8s.pod.cpu.usage",
+    "k8s.pod.cpu_request_utilization",
+    "k8s.pod.cpu_limit_utilization",
+    "k8s.pod.memory.working_set",
+    "k8s.pod.memory_request_utilization",
+    "k8s.pod.memory_limit_utilization",
+    "k8s.pod.phase",
+}
+
+# Numeric values emitted by the k8s.pod.phase metric (OTel kubeletstatsreceiver).
+PHASE_NUM = {"pending": 1, "running": 2, "succeeded": 3, "failed": 4, "unknown": 5}
+
+# Placeholder in JSONL labels that gets substituted with a runtime ISO string.
+START_TIME_PLACEHOLDER = "__START_TIME__"
+
+
+def _load_pods_metrics(
+    file_relpath: str,
+    base_time: datetime,
+    start_time: datetime | None = None,
+) -> list[Metrics]:
+    """Load pod metrics JSONL with optional k8s.pod.start_time substitution.
+
+    Mirrors Metrics.load_from_file's base_time rebase logic but adds a hook
+    for the start_time label. Lines carrying ``k8s.pod.start_time =
+    __START_TIME__`` get rewritten to ``start_time.isoformat()`` before
+    construction, ensuring podAge is deterministic across runs.
+    """
+    path = get_testdata_file_path(file_relpath)
+    start_time_iso = start_time.isoformat() if start_time else None
+    rows = []
+    with open(path, encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            data = json.loads(line)
+            labels = data.get("labels", {})
+            if start_time_iso and labels.get("k8s.pod.start_time") == START_TIME_PLACEHOLDER:
+                labels["k8s.pod.start_time"] = start_time_iso
+            rows.append(data)
+    if not rows:
+        return []
+    earliest = min(parse_timestamp(r["timestamp"]) for r in rows)
+    offset = base_time - earliest
+    metrics = []
+    for r in rows:
+        ts = parse_timestamp(r["timestamp"]) + offset
+        r["timestamp"] = ts.isoformat()
+        metrics.append(Metrics.from_dict(r))
+    return metrics
+
+
+def test_pods_accuracy(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Seed 2 pods x 7 metrics; assert response shape/contract + exact per-pod
+    metric values, podAge, and podCountsByPhase against precomputed expected
+    output. Locks in numerical determinism."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    start_time = now - timedelta(minutes=10)
+    insert_metrics(
+        _load_pods_metrics(
+            "inframonitoring/pods_value_accuracy.jsonl",
+            base_time=now - timedelta(minutes=4),
+            start_time=start_time,
+        )
+    )
+
+    with open(
+        get_testdata_file_path("inframonitoring/pods_value_accuracy_expected.json"),
+        encoding="utf-8",
+    ) as f:
+        expected = json.load(f)
+    exp_by_name = {r["podName"]: r for r in expected["records"]}
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    req_end_ms = int(now.timestamp() * 1000)
+    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": req_end_ms,
+            "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["meta"]["k8s.pod.name"] for r in data["records"]} == set(exp_by_name.keys())
+
+    # podAge = req.End - k8s.pod.start_time (in milliseconds). Verified equal to
+    # the precise expected value computed from the test's known start_time.
+    expected_age_ms = req_end_ms - int(start_time.timestamp() * 1000)
+
+    for record in data["records"]:
+        for field in (
+            "podUID",
+            "podCPU",
+            "podCPURequest",
+            "podCPULimit",
+            "podMemory",
+            "podMemoryRequest",
+            "podMemoryLimit",
+            "podPhase",
+            "podCountsByPhase",
+            "podAge",
+            "meta",
+        ):
+            assert field in record, f"missing {field} in {record!r}"
+
+        # Five phase buckets always present, integer-typed.
+        for bucket in ("pending", "running", "succeeded", "failed", "unknown"):
+            assert bucket in record["podCountsByPhase"], f"missing phase bucket {bucket} in {record['podCountsByPhase']!r}"
+            assert isinstance(record["podCountsByPhase"][bucket], int)
+
+        # Exact values.
+        pod_name = record["meta"]["k8s.pod.name"]
+        exp = exp_by_name[pod_name]
+        for field in (
+            "podCPU",
+            "podCPURequest",
+            "podCPULimit",
+            "podMemory",
+            "podMemoryRequest",
+            "podMemoryLimit",
+        ):
+            assert compare_values(record[field], exp[field], 1e-9), f"{pod_name}.{field}: got {record[field]}, expected {exp[field]}"
+        assert record["podPhase"] == exp["podPhase"]
+        assert record["podCountsByPhase"] == exp["podCountsByPhase"]
+        assert record["podAge"] == expected_age_ms, f"{pod_name}.podAge: got {record['podAge']}, expected {expected_age_ms}"
+
+
+def test_pods_missing_metrics(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Seed only k8s.pod.cpu.usage; assert other 6 required metrics flagged missing.
+
+    The endpoint short-circuits and returns empty records + total=0 when any
+    required metric is missing (module.go:192-197).
+    """
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        _load_pods_metrics(
+            "inframonitoring/pods_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.pod.cpu.usage"})
+    assert data["records"] == []
+    assert data["total"] == 0
+
+
+@pytest.mark.parametrize(
+    "expression,expected_pods",
+    [
+        pytest.param(
+            "k8s.namespace.name = 'ns-prod' AND k8s.deployment.name = 'web'",
+            {"web-prod-1", "web-prod-2"},
+            id="and",
+        ),
+        pytest.param(
+            "k8s.pod.name IN ('web-prod-1', 'api-dev-1')",
+            {"web-prod-1", "api-dev-1"},
+            id="in",
+        ),
+        pytest.param(
+            "k8s.deployment.name NOT IN ('api')",
+            {"web-prod-1", "web-prod-2", "web-dev-1", "web-dev-2"},
+            id="not_in",
+        ),
+        pytest.param(
+            "k8s.pod.name CONTAINS 'web'",
+            {"web-prod-1", "web-prod-2", "web-dev-1", "web-dev-2"},
+            id="contains",
+        ),
+        pytest.param(
+            "k8s.namespace.name = 'ns-prod' AND k8s.pod.name IN ('web-prod-1', 'api-prod-1')",
+            {"web-prod-1", "api-prod-1"},
+            id="and_in",
+        ),
+        pytest.param(
+            "k8s.namespace.name = 'ns-prod' AND k8s.pod.name NOT IN ('web-prod-1', 'web-prod-2')",
+            {"api-prod-1", "api-prod-2"},
+            id="and_not_in",
+        ),
+        pytest.param(
+            "k8s.namespace.name = 'ns-dev' AND k8s.pod.name CONTAINS 'web'",
+            {"web-dev-1", "web-dev-2"},
+            id="and_contains",
+        ),
+        pytest.param(
+            "k8s.pod.name IN ('web-prod-1', 'web-dev-1', 'api-dev-1') AND k8s.pod.name CONTAINS 'web'",
+            {"web-prod-1", "web-dev-1"},
+            id="in_contains",
+        ),
+    ],
+)
+def test_pods_filter(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    expression: str,
+    expected_pods: set,
+) -> None:
+    """Filter operators (=, IN, NOT IN, CONTAINS) and their AND-combinations
+    return exactly the matching pods, with undistorted per-pod metric values."""
+    # Every pod in pods_filter_dataset.jsonl carries the same sample pattern
+    # as acc-p1 in pods_value_accuracy.jsonl, so all filtered records must
+    # resolve to these exact values (mirrors pods_value_accuracy_expected.json
+    # acc-p1).
+    expected_values = {
+        "podCPU": 0.5,
+        "podCPURequest": 0.25,
+        "podCPULimit": 0.5,
+        "podMemory": 524288000.0,
+        "podMemoryRequest": 0.5,
+        "podMemoryLimit": 0.25,
+    }
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        _load_pods_metrics(
+            "inframonitoring/pods_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["meta"]["k8s.pod.name"] for r in data["records"]} == expected_pods
+    assert data["total"] == len(expected_pods)
+
+    # Filtering must not distort per-pod aggregation values.
+    for record in data["records"]:
+        for field in expected_values:
+            assert compare_values(record[field], expected_values[field], 1e-9), f"{record['meta']['k8s.pod.name']}.{field}: got {record[field]}, expected {expected_values[field]}"
+
+
+@pytest.mark.parametrize(
+    "expression,err_substr",
+    [
+        pytest.param("k8s.pod.namee = 'web-prod-1'", "k8s.pod.namee", id="bad_attr_name"),
+        pytest.param("k8s.pod.name =", None, id="trailing_op"),
+        pytest.param("(k8s.pod.name = 'web-prod-1'", None, id="unclosed_paren"),
+    ],
+)
+def test_pods_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(
+        _load_pods_metrics(
+            "inframonitoring/pods_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}"
+
+
+# Pod names per phase in pods_phases.jsonl (generated by tests/gen_pods_datasets.py).
+_PHASE_TO_POD_NAME = {
+    "pending": "pend-p",
+    "running": "run-p",
+    "succeeded": "succ-p",
+    "failed": "fail-p",
+    "unknown": "unk-p",
+}
+
+
+@pytest.mark.parametrize(
+    "phase_name",
+    [
+        pytest.param("pending", id="pending"),
+        pytest.param("running", id="running"),
+        pytest.param("succeeded", id="succeeded"),
+        pytest.param("failed", id="failed"),
+        pytest.param("unknown", id="unknown"),
+    ],
+)
+def test_pods_phase_counts_list_mode(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    phase_name: str,
+) -> None:
+    """List mode (no groupBy): each pod's record carries podPhase derived from its
+    latest k8s.pod.phase sample, AND podCountsByPhase has exactly that bucket=1
+    with all others 0. Verifies the phase-derivation logic at pods.go:82-94.
+    """
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        _load_pods_metrics(
+            "inframonitoring/pods_phases.jsonl",
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    pod_name = _PHASE_TO_POD_NAME[phase_name]
+    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": f"k8s.pod.name = '{pod_name}'"},
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 1
+    rec = data["records"][0]
+    assert rec["meta"]["k8s.pod.name"] == pod_name
+    assert rec["podPhase"] == phase_name
+    assert rec["podCountsByPhase"][phase_name] == 1
+    for other in {"pending", "running", "succeeded", "failed", "unknown"} - {phase_name}:
+        assert rec["podCountsByPhase"][other] == 0, f"expected {other}=0 when latest phase={phase_name}, got {rec['podCountsByPhase']}"
+
+
+def test_pods_phase_counts_latest_wins(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Pod with k8s.pod.phase transitioning pending->running across the window:
+    podPhase reflects the LATEST sample (running) via argMax, not the earliest.
+    """
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        _load_pods_metrics(
+            "inframonitoring/pods_phases_transition.jsonl",
+            base_time=now - timedelta(minutes=8),
+        )
+    )
+
+    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=10)).timestamp() * 1000),
+            "end": int(now.timestamp() * 1000),
+            "limit": 50,
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 1
+    rec = data["records"][0]
+    assert rec["meta"]["k8s.pod.name"] == "trans-p"
+    assert rec["podPhase"] == "running"
+    assert rec["podCountsByPhase"]["running"] == 1
+    assert rec["podCountsByPhase"]["pending"] == 0
+
+
+def test_pods_phase_counts_grouped_mode(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """groupBy=[k8s.namespace.name] aggregates phase counts across all pods in
+    the group. podPhase becomes "no_data" because no single pod identifies the
+    group, and per-pod fields (podUID, podAge, meta) clear out.
+    Dataset: ns-mixed contains 3 running + 2 failed + 1 pending.
+    See pods.go:80-95 (list-vs-grouped phase handling).
+    """
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        _load_pods_metrics(
+            "inframonitoring/pods_phases_grouped.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": "k8s.namespace.name",
+                    "fieldDataType": "string",
+                    "fieldContext": "resource",
+                }
+            ],
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 1
+    rec = data["records"][0]
+
+    # Grouped-mode invariants: per-pod fields cleared, but meta surfaces the
+    # groupBy key so the client can identify the group.
+    assert rec["podUID"] == ""
+    assert rec["podAge"] == -1
+    assert rec["podPhase"] == "no_data"
+    assert rec["meta"].get("k8s.namespace.name") == "ns-mixed"
+
+    # Aggregated phase counts across the namespace.
+    assert rec["podCountsByPhase"] == {
+        "pending": 1,
+        "running": 3,
+        "succeeded": 0,
+        "failed": 2,
+        "unknown": 0,
+    }
+
+
+@pytest.mark.parametrize(
+    "group_key,expected_groups",
+    [
+        pytest.param("k8s.namespace.name", {"gns-a", "gns-b"}, id="namespace"),
+        pytest.param("k8s.deployment.name", {"gdep-x", "gdep-y"}, id="deployment"),
+    ],
+)
+def test_pods_groupby(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    group_key: str,
+    expected_groups: set,
+) -> None:
+    """groupBy aggregates 2 pods per group into one record. Per-pod identity
+    fields (uid, age, phase) are cleared, but meta must surface the groupBy
+    key so the client can identify each group.
+    """
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        _load_pods_metrics(
+            "inframonitoring/pods_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_groups)
+    assert len(data["records"]) == len(expected_groups)
+
+    groups_seen = set()
+    for rec in data["records"]:
+        assert rec["podUID"] == ""
+        assert rec["podPhase"] == "no_data"
+        assert rec["podAge"] == -1
+        # meta surfaces the groupBy key so the client can identify the group.
+        assert group_key in rec["meta"], rec["meta"]
+        groups_seen.add(rec["meta"][group_key])
+        # Each group has 2 running pods.
+        assert rec["podCountsByPhase"]["running"] == 2
+        for other in ("pending", "succeeded", "failed", "unknown"):
+            assert rec["podCountsByPhase"][other] == 0
+    assert groups_seen == expected_groups
+
+
+def test_pods_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(
+        _load_pods_metrics(
+            "inframonitoring/pods_pagination.jsonl",
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    K, limit = 7, 3
+    seen_pods: 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,
+            },
+            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} records, got {len(data['records'])}"
+        seen_pods.extend(r["meta"]["k8s.pod.name"] for r in data["records"])
+
+    assert seen_totals == {K}
+    assert len(seen_pods) == K
+    assert set(seen_pods) == {f"page-p{i}" for i in range(1, K + 1)}
+
+
+# orderBy keys per pods_constants.go:42-48 (snake_case request keys, camelCase
+# response fields). k8s.pod.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", "podCPU", id="cpu"),
+        pytest.param("cpu_request", "podCPURequest", id="cpu_request"),
+        pytest.param("cpu_limit", "podCPULimit", id="cpu_limit"),
+        pytest.param("memory", "podMemory", id="memory"),
+        pytest.param("memory_request", "podMemoryRequest", id="memory_request"),
+        pytest.param("memory_limit", "podMemoryLimit", id="memory_limit"),
+        pytest.param("k8s.pod.name", None, id="pod_name"),
+    ],
+)
+@pytest.mark.parametrize("direction", ["asc", "desc"])
+def test_pods_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,
+    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(
+        _load_pods_metrics(
+            "inframonitoring/pods_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 pods seeded by other tests in the shared backend.
+            "filter": {"expression": "k8s.pod.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'])}"
+
+    # record_field None => pod name lives in meta, not a top-level field.
+    values = [r["meta"]["k8s.pod.name"] if record_field is None else 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": "phase"}, "direction": "desc"}},
+            "invalid order by key",
+            id="orderby_phase_rejected",
+        ),
+        pytest.param(
+            {"orderBy": {"key": {"name": "cpu"}, "direction": "up"}},
+            "invalid order by direction",
+            id="orderby_invalid_direction",
+        ),
+        pytest.param(
+            {
+                "orderBy": {
+                    "key": {"name": "k8s.pod.name"},
+                    "direction": "desc",
+                },
+                "groupBy": [
+                    {
+                        "name": "k8s.namespace.name",
+                        "fieldDataType": "string",
+                        "fieldContext": "resource",
+                    }
+                ],
+            },
+            "is only allowed when groupBy is empty",
+            id="orderby_podname_with_groupby",
+        ),
+    ],
+)
+def test_pods_validation_errors(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    payload_override: dict,
+    err_substr: str,
+) -> None:
+    """All PostablePods.Validate() rules reject with 400 + descriptive error.
+    See pkg/types/inframonitoringtypes/pods.go:56-107."""
+    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}"

tests/integration/tests/inframonitoring/03_nodes.py

@@ -0,0 +1,749 @@
+"""Integration tests for v2 infra-monitoring node 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/nodes"
+
+# Required metrics for the v2 nodes endpoint
+# (pkg/modules/inframonitoring/implinframonitoring/nodes_constants.go:22-29).
+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",
+}
+
+# Numeric values emitted by k8s.node.condition_ready.
+COND_NUM = {"ready": 1, "not_ready": 0}
+
+
+def test_nodes_accuracy(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Seed 2 nodes x 5 metrics + pods; assert response shape/contract + exact
+    per-node metric values, condition, and both count buckets against
+    precomputed expected output."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/nodes_value_accuracy.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    with open(
+        get_testdata_file_path("inframonitoring/nodes_value_accuracy_expected.json"),
+        encoding="utf-8",
+    ) as f:
+        expected = json.load(f)
+    exp_by_name = {r["nodeName"]: 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["nodeName"] for r in data["records"]} == set(exp_by_name.keys())
+
+    for record in data["records"]:
+        for field in (
+            "nodeName",
+            "condition",
+            "nodeCountsByReadiness",
+            "podCountsByPhase",
+            "nodeCPU",
+            "nodeCPUAllocatable",
+            "nodeMemory",
+            "nodeMemoryAllocatable",
+            "meta",
+        ):
+            assert field in record, f"missing {field} in {record!r}"
+
+        for bucket in ("ready", "notReady"):
+            assert bucket in record["nodeCountsByReadiness"]
+        for bucket in ("pending", "running", "succeeded", "failed", "unknown"):
+            assert bucket in record["podCountsByPhase"]
+
+        assert record["meta"].get("k8s.node.name") == record["nodeName"]
+        assert "k8s.node.uid" in record["meta"]
+        assert "k8s.cluster.name" in record["meta"]
+
+        # Exact values.
+        exp = exp_by_name[record["nodeName"]]
+        for field in ("nodeCPU", "nodeCPUAllocatable", "nodeMemory", "nodeMemoryAllocatable"):
+            assert compare_values(record[field], exp[field], 1e-6), f"{record['nodeName']}.{field}: got {record[field]}, expected {exp[field]}"
+        assert record["condition"] == exp["condition"]
+        assert record["nodeCountsByReadiness"] == exp["nodeCountsByReadiness"]
+        assert record["podCountsByPhase"] == exp["podCountsByPhase"]
+
+
+def test_nodes_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/nodes_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_nodes",
+    [
+        pytest.param(
+            "k8s.cluster.name = 'cluster-a' AND zone = 'us'",
+            {"web-a-us-1", "api-a-us-1"},
+            id="and",
+        ),
+        pytest.param(
+            "k8s.node.name IN ('web-a-us-1', 'api-b-eu-1')",
+            {"web-a-us-1", "api-b-eu-1"},
+            id="in",
+        ),
+        pytest.param(
+            "k8s.cluster.name NOT IN ('cluster-a')",
+            {"web-b-us-1", "web-b-eu-1", "api-b-us-1", "api-b-eu-1"},
+            id="not_in",
+        ),
+        pytest.param(
+            "k8s.node.name CONTAINS 'web'",
+            {"web-a-us-1", "web-a-eu-1", "web-b-us-1", "web-b-eu-1"},
+            id="contains",
+        ),
+        pytest.param(
+            "k8s.cluster.name = 'cluster-a' AND k8s.node.name IN ('web-a-us-1', 'api-a-us-1')",
+            {"web-a-us-1", "api-a-us-1"},
+            id="and_in",
+        ),
+        pytest.param(
+            "k8s.cluster.name = 'cluster-a' AND k8s.node.name NOT IN ('web-a-us-1', 'web-a-eu-1')",
+            {"api-a-us-1", "api-a-eu-1"},
+            id="and_not_in",
+        ),
+        pytest.param(
+            "zone = 'us' AND k8s.node.name CONTAINS 'web'",
+            {"web-a-us-1", "web-b-us-1"},
+            id="and_contains",
+        ),
+        pytest.param(
+            "k8s.node.name IN ('web-a-us-1', 'web-b-us-1', 'api-a-us-1') AND k8s.node.name CONTAINS 'web'",
+            {"web-a-us-1", "web-b-us-1"},
+            id="in_contains",
+        ),
+    ],
+)
+def test_nodes_filter(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    expression: str,
+    expected_nodes: set,
+) -> None:
+    """Filter operators (=, IN, NOT IN, CONTAINS) and their AND-combinations
+    return exactly the matching nodes, with undistorted per-node metric values."""
+    # Every node in nodes_filter_dataset.jsonl carries the same sample pattern
+    # as acc-n1 in nodes_value_accuracy.jsonl, so all filtered records must
+    # resolve to these exact values (mirrors nodes_value_accuracy_expected.json
+    # acc-n1).
+    expected_values = {
+        "nodeCPU": 1.0,
+        "nodeCPUAllocatable": 4.0,
+        "nodeMemory": 2000000000.0,
+        "nodeMemoryAllocatable": 8000000000.0,
+    }
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/nodes_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["nodeName"] for r in data["records"]} == expected_nodes
+    assert data["total"] == len(expected_nodes)
+
+    # Filtering must not distort per-node aggregation values.
+    for record in data["records"]:
+        for field in expected_values:
+            assert compare_values(record[field], expected_values[field], 1e-6), f"{record['nodeName']}.{field}: got {record[field]}, expected {expected_values[field]}"
+
+
+@pytest.mark.parametrize(
+    "expression,err_substr",
+    [
+        pytest.param("k8s.node.namee = 'web-a-us-1'", "k8s.node.namee", id="bad_attr_name"),
+        pytest.param("k8s.node.name =", None, id="trailing_op"),
+        pytest.param("(k8s.node.name = 'web-a-us-1'", None, id="unclosed_paren"),
+    ],
+)
+def test_nodes_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/nodes_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}"
+
+
+@pytest.mark.parametrize(
+    "node_name,expected_condition",
+    [
+        pytest.param("ready-n", "ready", id="ready"),
+        pytest.param("notready-n", "not_ready", id="not_ready"),
+    ],
+)
+def test_nodes_condition_list_mode(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+    node_name: str,
+    expected_condition: str,
+) -> None:
+    """List mode: each node's record carries condition derived from latest
+    k8s.node.condition_ready sample. Counts match per nodes.go:69-76."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/nodes_conditions.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": f"k8s.node.name = '{node_name}'"},
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 1
+    rec = data["records"][0]
+    assert rec["nodeName"] == node_name
+    assert rec["condition"] == expected_condition
+    if expected_condition == "ready":
+        assert rec["nodeCountsByReadiness"] == {"ready": 1, "notReady": 0}
+    else:
+        assert rec["nodeCountsByReadiness"] == {"ready": 0, "notReady": 1}
+
+
+def test_nodes_condition_latest_wins(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Node with condition_ready transitioning 0->1: latest argMax wins -> ready.
+
+    Note: the dataset also seeds a phantom k8s.pod.phase sample (otherwise the
+    nodes endpoint short-circuits — pod.phase is in nodesTableMetricNamesList).
+    The phantom surfaces as an extra node via the metadata getter (which groups
+    by k8s.node.name across ALL required-metric series, including pod-phase),
+    so the test filters explicitly to the trans-n node.
+    """
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/nodes_conditions_transition.jsonl"),
+            base_time=now - timedelta(minutes=8),
+        )
+    )
+
+    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=10)).timestamp() * 1000),
+            "end": int(now.timestamp() * 1000),
+            "limit": 50,
+            "filter": {"expression": "k8s.node.name = 'trans-n'"},
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 1
+    rec = data["records"][0]
+    assert rec["nodeName"] == "trans-n"
+    assert rec["condition"] == "ready"
+    assert rec["nodeCountsByReadiness"] == {"ready": 1, "notReady": 0}
+
+
+def test_nodes_condition_grouped_mode(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """groupBy=[k8s.cluster.name] aggregates condition counts across nodes.
+    Per the contract (nodes.go:69-76): condition stays no_data in grouped mode."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/nodes_conditions_grouped.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": "k8s.cluster.name",
+                    "fieldDataType": "string",
+                    "fieldContext": "resource",
+                }
+            ],
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 1
+    rec = data["records"][0]
+
+    # Grouped-mode invariants: per-node fields cleared.
+    assert rec["nodeName"] == ""
+    assert rec["condition"] == "no_data"
+    # Aggregated condition counts across the cluster.
+    assert rec["nodeCountsByReadiness"] == {"ready": 2, "notReady": 1}
+    # Pod-phase counts aggregated: 3 running pods (one per node).
+    assert rec["podCountsByPhase"]["running"] == 3
+    for other in ("pending", "succeeded", "failed", "unknown"):
+        assert rec["podCountsByPhase"][other] == 0
+    # meta surfaces the groupBy key.
+    assert rec["meta"].get("k8s.cluster.name") == "cluster-mixed"
+
+
+def test_nodes_pod_phase_counts_list_mode(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Node hosts 3 running + 2 failed pods: podCountsByPhase bucketed correctly.
+    Verifies the k8s.pod.phase join via k8s.node.name in labels."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/nodes_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,
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 1
+    rec = data["records"][0]
+    assert rec["nodeName"] == "pp-n1"
+    assert rec["podCountsByPhase"] == {
+        "pending": 0,
+        "running": 3,
+        "succeeded": 0,
+        "failed": 2,
+        "unknown": 0,
+    }
+
+
+def test_nodes_pod_phase_counts_no_pods_on_node(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Node with no pods: podCountsByPhase all zeros, node still appears.
+    Filter on the specific node to ignore the carrier phantom (see
+    test_nodes_condition_latest_wins for the carrier explanation).
+    """
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/nodes_no_pods.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.node.name = 'no-pod-n'"},
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 1
+    rec = data["records"][0]
+    assert rec["nodeName"] == "no-pod-n"
+    assert rec["podCountsByPhase"] == {
+        "pending": 0,
+        "running": 0,
+        "succeeded": 0,
+        "failed": 0,
+        "unknown": 0,
+    }
+
+
+def test_nodes_groupby_cluster(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Explicit groupBy=[k8s.cluster.name]: 2 records (one per cluster),
+    aggregated node + pod counts, meta surfaces cluster.name."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/nodes_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": "k8s.cluster.name",
+                    "fieldDataType": "string",
+                    "fieldContext": "resource",
+                }
+            ],
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 2
+
+    clusters_seen = set()
+    for rec in data["records"]:
+        assert rec["nodeName"] == ""
+        assert rec["condition"] == "no_data"
+        # Each cluster has 2 nodes -> nodeCountsByReadiness {ready:2, notReady:0}
+        assert rec["nodeCountsByReadiness"] == {"ready": 2, "notReady": 0}
+        # Each cluster has 2 pods (1 per node).
+        assert rec["podCountsByPhase"]["running"] == 2
+        assert "k8s.cluster.name" in rec["meta"], rec["meta"]
+        clusters_seen.add(rec["meta"]["k8s.cluster.name"])
+    assert clusters_seen == {"gb-cluster-a", "gb-cluster-b"}
+
+
+def test_nodes_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/nodes_pagination.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    token = get_token(USER_ADMIN_EMAIL, USER_ADMIN_PASSWORD)
+    K, limit = 7, 3
+    seen_nodes: 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,
+                # Exclude the dataset's carrier phantom (see test_nodes_condition_latest_wins).
+                "filter": {"expression": "k8s.node.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} records, got {len(data['records'])}"
+        seen_nodes.extend(r["nodeName"] for r in data["records"])
+
+    assert seen_totals == {K}
+    assert len(seen_nodes) == K
+    assert set(seen_nodes) == {f"page-n{i}" for i in range(1, K + 1)}
+
+
+# orderBy keys per nodes_constants.go:33-37 (snake_case request keys,
+# camelCase response fields). k8s.node.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", "nodeCPU", id="cpu"),
+        pytest.param("cpu_allocatable", "nodeCPUAllocatable", id="cpu_allocatable"),
+        pytest.param("memory", "nodeMemory", id="memory"),
+        pytest.param("memory_allocatable", "nodeMemoryAllocatable", id="memory_allocatable"),
+        pytest.param("k8s.node.name", "nodeName", id="node_name"),
+    ],
+)
+@pytest.mark.parametrize("direction", ["asc", "desc"])
+def test_nodes_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/nodes_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 nodes seeded by other tests in the shared backend.
+            "filter": {"expression": "k8s.node.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": "condition"}, "direction": "desc"}},
+            "invalid order by key",
+            id="orderby_condition_rejected",
+        ),
+        pytest.param(
+            {"orderBy": {"key": {"name": "cpu"}, "direction": "up"}},
+            "invalid order by direction",
+            id="orderby_invalid_direction",
+        ),
+        pytest.param(
+            {
+                "orderBy": {"key": {"name": "k8s.node.name"}, "direction": "desc"},
+                "groupBy": [
+                    {
+                        "name": "k8s.cluster.name",
+                        "fieldDataType": "string",
+                        "fieldContext": "resource",
+                    }
+                ],
+            },
+            "is only allowed when groupBy is empty",
+            id="orderby_nodename_with_groupby",
+        ),
+    ],
+)
+def test_nodes_validation_errors(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    payload_override: dict,
+    err_substr: str,
+) -> None:
+    """All PostableNodes.Validate() rules reject with 400 + descriptive error.
+    See pkg/types/inframonitoringtypes/nodes.go:51-102."""
+    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}"

tests/integration/tests/inframonitoring/04_namespaces.py

@@ -0,0 +1,544 @@
+"""Integration tests for v2 infra-monitoring namespace 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/namespaces"
+
+# Required metrics for the v2 namespaces endpoint
+# (pkg/modules/inframonitoring/implinframonitoring/namespaces_constants.go:22-26).
+REQUIRED_METRICS = {
+    "k8s.pod.cpu.usage",
+    "k8s.pod.memory.working_set",
+    "k8s.pod.phase",
+}
+
+
+def test_namespaces_accuracy(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Seed 2 namespaces x 3 metrics; assert response shape/contract + exact
+    per-namespace metric values and podCountsByPhase.
+
+    Tests v1-parity expectation: SpaceAggregationSum across pods within a
+    namespace (pods_query.go A=cpu, D=memory both use Sum, namespaces.go:225
+    clones PodsTableListQuery; v2 namespaces_constants.go:54,73 use Sum too).
+    Predicted: acc-ns-1 (2 pods @ cpu=0.5,mem=1e8) -> cpu=1.0, mem=2e8;
+    acc-ns-2 (3 pods @ cpu=0.75,mem=2e8) -> cpu=2.25, mem=6e8.
+    """
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/namespaces_value_accuracy.jsonl"),
+            base_time=now - timedelta(minutes=4),
+        )
+    )
+
+    with open(
+        get_testdata_file_path("inframonitoring/namespaces_value_accuracy_expected.json"),
+        encoding="utf-8",
+    ) as f:
+        expected = json.load(f)
+    exp_by_name = {r["namespaceName"]: 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["namespaceName"] for r in data["records"]} == set(exp_by_name.keys())
+
+    for record in data["records"]:
+        for field in (
+            "namespaceName",
+            "namespaceCPU",
+            "namespaceMemory",
+            "podCountsByPhase",
+            "meta",
+        ):
+            assert field in record, f"missing {field} in {record!r}"
+
+        for bucket in ("pending", "running", "succeeded", "failed", "unknown"):
+            assert bucket in record["podCountsByPhase"]
+            assert isinstance(record["podCountsByPhase"][bucket], int)
+
+        assert record["meta"].get("k8s.namespace.name") == record["namespaceName"]
+        assert "k8s.cluster.name" in record["meta"]
+
+        # Exact values.
+        exp = exp_by_name[record["namespaceName"]]
+        for field in ("namespaceCPU", "namespaceMemory"):
+            assert compare_values(record[field], exp[field], 1e-6), f"{record['namespaceName']}.{field}: got {record[field]}, expected {exp[field]}"
+        assert record["podCountsByPhase"] == exp["podCountsByPhase"]
+
+
+def test_namespaces_missing_metrics(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Seed only k8s.pod.cpu.usage; assert other 2 required metrics flagged missing."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/namespaces_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.pod.cpu.usage"})
+    assert data["records"] == []
+    assert data["total"] == 0
+
+
+@pytest.mark.parametrize(
+    "expression,expected",
+    [
+        pytest.param(
+            "k8s.cluster.name = 'cluster-a' AND env = 'prod'",
+            {"web-a-prod", "api-a-prod"},
+            id="and",
+        ),
+        pytest.param(
+            "k8s.namespace.name IN ('web-a-prod', 'api-b-dev')",
+            {"web-a-prod", "api-b-dev"},
+            id="in",
+        ),
+        pytest.param(
+            "k8s.cluster.name NOT IN ('cluster-a')",
+            {"web-b-prod", "web-b-dev", "api-b-prod", "api-b-dev"},
+            id="not_in",
+        ),
+        pytest.param(
+            "k8s.namespace.name CONTAINS 'web'",
+            {"web-a-prod", "web-a-dev", "web-b-prod", "web-b-dev"},
+            id="contains",
+        ),
+        pytest.param(
+            "k8s.cluster.name = 'cluster-a' AND k8s.namespace.name IN ('web-a-prod', 'api-a-prod')",
+            {"web-a-prod", "api-a-prod"},
+            id="and_in",
+        ),
+        pytest.param(
+            "k8s.cluster.name = 'cluster-a' AND k8s.namespace.name NOT IN ('web-a-prod', 'web-a-dev')",
+            {"api-a-prod", "api-a-dev"},
+            id="and_not_in",
+        ),
+        pytest.param(
+            "env = 'prod' AND k8s.namespace.name CONTAINS 'web'",
+            {"web-a-prod", "web-b-prod"},
+            id="and_contains",
+        ),
+        pytest.param(
+            "k8s.namespace.name IN ('web-a-prod', 'web-b-prod', 'api-a-prod') AND k8s.namespace.name CONTAINS 'web'",
+            {"web-a-prod", "web-b-prod"},
+            id="in_contains",
+        ),
+    ],
+)
+def test_namespaces_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 namespaces, with undistorted per-namespace
+    metric values."""
+    # Every namespace in namespaces_filter_dataset.jsonl carries the same
+    # sample pattern as acc-ns-1 in namespaces_value_accuracy.jsonl (2 pods),
+    # so all filtered records must resolve to these exact values (mirrors
+    # namespaces_value_accuracy_expected.json acc-ns-1).
+    expected_values = {
+        "namespaceCPU": 1.0,
+        "namespaceMemory": 200000000.0,
+    }
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/namespaces_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["namespaceName"] for r in data["records"]} == expected
+    assert data["total"] == len(expected)
+
+    # Filtering must not distort per-namespace aggregation values.
+    for record in data["records"]:
+        for field in expected_values:
+            assert compare_values(record[field], expected_values[field], 1e-6), f"{record['namespaceName']}.{field}: got {record[field]}, expected {expected_values[field]}"
+
+
+@pytest.mark.parametrize(
+    "expression,err_substr",
+    [
+        pytest.param("k8s.namespace.namee = 'web-a-prod'", "k8s.namespace.namee", id="bad_attr_name"),
+        pytest.param("k8s.namespace.name =", None, id="trailing_op"),
+        pytest.param("(k8s.namespace.name = 'web-a-prod'", None, id="unclosed_paren"),
+    ],
+)
+def test_namespaces_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/namespaces_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_namespaces_pod_phase_aggregation(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Namespace with mixed pod phases: podCountsByPhase aggregates correctly.
+    Dataset: 4 running + 1 pending + 2 failed pods all in pp-ns."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/namespaces_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.namespace.name = 'pp-ns'"},
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 1
+    rec = data["records"][0]
+    assert rec["namespaceName"] == "pp-ns"
+    assert rec["podCountsByPhase"] == {
+        "pending": 1,
+        "running": 4,
+        "succeeded": 0,
+        "failed": 2,
+        "unknown": 0,
+    }
+
+
+def test_namespaces_groupby_cluster(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    insert_metrics,
+) -> None:
+    """Explicit groupBy=[k8s.cluster.name]: 2 records, aggregated counts per cluster,
+    meta surfaces cluster.name. Each cluster has 2 namespaces with 1 running pod each."""
+    now = datetime.now(tz=UTC).replace(microsecond=0)
+    insert_metrics(
+        Metrics.load_from_file(
+            get_testdata_file_path("inframonitoring/namespaces_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": "k8s.cluster.name",
+                    "fieldDataType": "string",
+                    "fieldContext": "resource",
+                }
+            ],
+        },
+        timeout=5,
+    )
+    assert response.status_code == HTTPStatus.OK, response.text
+    data = response.json()["data"]
+    assert data["total"] == 2
+
+    clusters_seen = set()
+    for rec in data["records"]:
+        # Per-row namespace identity is cleared; only the groupBy field surfaces.
+        assert rec["namespaceName"] == ""
+        # Each cluster has 2 namespaces x 1 pod = 2 running pods.
+        assert rec["podCountsByPhase"]["running"] == 2
+        for other in ("pending", "succeeded", "failed", "unknown"):
+            assert rec["podCountsByPhase"][other] == 0
+        assert "k8s.cluster.name" in rec["meta"], rec["meta"]
+        clusters_seen.add(rec["meta"]["k8s.cluster.name"])
+    assert clusters_seen == {"gb-cluster-a", "gb-cluster-b"}
+
+
+def test_namespaces_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/namespaces_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,
+            },
+            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["namespaceName"] for r in data["records"])
+
+    assert seen_totals == {K}
+    assert len(seen_names) == K
+    assert set(seen_names) == {f"page-ns-{i}" for i in range(1, K + 1)}
+
+
+# orderBy keys per namespaces_constants.go (cpu, memory only).
+# k8s.namespace.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", "namespaceCPU", id="cpu"),
+        pytest.param("memory", "namespaceMemory", id="memory"),
+        pytest.param("k8s.namespace.name", "namespaceName", id="namespace_name"),
+    ],
+)
+@pytest.mark.parametrize("direction", ["asc", "desc"])
+def test_namespaces_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/namespaces_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 namespaces seeded by other tests in the shared backend.
+            "filter": {"expression": "k8s.namespace.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.namespace.name"}, "direction": "desc"},
+                "groupBy": [
+                    {
+                        "name": "k8s.cluster.name",
+                        "fieldDataType": "string",
+                        "fieldContext": "resource",
+                    }
+                ],
+            },
+            "is only allowed when groupBy is empty",
+            id="orderby_nsname_with_groupby",
+        ),
+    ],
+)
+def test_namespaces_validation_errors(
+    signoz: types.SigNoz,
+    create_user_admin: None,  # pylint: disable=unused-argument
+    get_token,
+    payload_override: dict,
+    err_substr: str,
+) -> None:
+    """All PostableNamespaces.Validate() rules reject with 400 + descriptive error.
+    See pkg/types/inframonitoringtypes/namespaces.go:40-91."""
+    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}"