The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
fix(o11y): support partial metric loading (#50867)
Chris Opland509afd0bf0d2
diff --git a/apps/studio/components/interfaces/Observability/DatabaseInfrastructureMetric.test.tsx b/apps/studio/components/interfaces/Observability/DatabaseInfrastructureMetric.test.tsxnew file mode 100644index 00000000000..8489965673e--- /dev/null+++ b/apps/studio/components/interfaces/Observability/DatabaseInfrastructureMetric.test.tsx@@ -0,0 +1,150 @@+import { QueryClient } from '@tanstack/react-query'+import { screen, waitFor, within } from '@testing-library/react'+import { HttpResponse } from 'msw'+import { describe, expect, it } from 'vitest'++import { DatabaseInfrastructureSection } from './DatabaseInfrastructureSection'+import type { InfraMonitoringMultiResponse } from '@/data/analytics/infra-monitoring-query'+import { databaseKeys } from '@/data/database/keys'+import { projectKeys } from '@/data/projects/keys'+import { customRender } from '@/tests/lib/custom-render'+import { addAPIMock, type APIErrorBody } from '@/tests/lib/msw'++const values: Record<string, number> = {+ avg_cpu_usage: 25,+ ram_usage: 60,+ disk_io_consumption: 40,+ disk_fs_used_system: 10,+ disk_fs_used_wal: 5,+ pg_database_size: 35,+ disk_fs_size: 100,+ pg_stat_database_num_backends: 12,+}++function mockMetrics(failedAttribute?: string, includeErrors = true) {+ const requests: string[][] = []+ addAPIMock({+ method: 'get',+ path: '/platform/projects/:ref/infra-monitoring',+ response: ({ request }) => {+ const attributes = new URL(request.url).searchParams.get('attributes')!.split(',')+ requests.push(attributes)+ const succeeded = attributes.filter(+ (attribute) => failedAttribute !== '*' && attribute !== failedAttribute+ )+ const failed = attributes.filter((attribute) => !succeeded.includes(attribute))+ const series = Object.fromEntries(+ succeeded.map((attribute) => [+ attribute,+ {+ totalAverage: values[attribute],+ total: values[attribute],+ format: '%',+ yAxisLimit: 100,+ },+ ])+ )+ const pointValues = Object.fromEntries(+ succeeded.map((attribute) => [attribute, String(values[attribute])])+ )+ return HttpResponse.json<InfraMonitoringMultiResponse>({+ series,+ data: succeeded.length+ ? [{ period_start: '2026-09-24T00:00:00Z', values: pointValues }]+ : [],+ ...(includeErrors+ ? {+ errors: Object.fromEntries(+ failed.map((attribute) => [attribute, { message: 'Metric is not supported' }])+ ),+ }+ : {}),+ })+ },+ })+ return requests+}++function renderMetrics() {+ const queryClient = new QueryClient({+ defaultOptions: { queries: { retry: false, staleTime: Infinity } },+ })+ queryClient.setQueryData(projectKeys.detail('default'), {+ ref: 'default',+ status: 'ACTIVE_HEALTHY',+ connectionString: 'postgresql://localhost/postgres',+ })+ queryClient.setQueryData(databaseKeys.maxConnections('default'), { maxConnections: 100 })+ customRender(+ <DatabaseInfrastructureSection+ interval="1day"+ refreshKey={0}+ dbErrorRate={0}+ isLoading={false}+ />,+ { queryClient }+ )+}++function card(label: string) {+ return within(screen.getByRole('link', { name: new RegExp(label) }))+}++describe('DatabaseInfrastructureSection batched metrics', () => {+ it.each([false, true])(+ 'renders all metrics from one request (errors field: %s)',+ async (includeErrors) => {+ const requests = mockMetrics(undefined, includeErrors)+ renderMetrics()++ expect(await card('CPU').findByText('25%')).toBeInTheDocument()+ expect(await card('Memory').findByText('60%')).toBeInTheDocument()+ expect(await card('Disk IO').findByText('40%')).toBeInTheDocument()+ expect(await card('Disk Usage').findByText('50%')).toBeInTheDocument()+ expect(await card('Peak Connections').findByText('12/100')).toBeInTheDocument()+ expect(requests).toHaveLength(1)+ expect(requests[0].sort()).toEqual(Object.keys(values).sort())+ }+ )++ it.each([+ ['disk_io_consumption', 'Disk IO'],+ ['disk_fs_used_wal', 'Disk Usage'],+ ['pg_stat_database_num_backends', 'Peak Connections'],+ ])('isolates a failed %s result to %s', async (attribute, label) => {+ const requests = mockMetrics(attribute)+ renderMetrics()++ expect(await card(label).findByText('Metric is not supported')).toBeInTheDocument()+ expect(await card('CPU').findByText('25%')).toBeInTheDocument()+ expect(await card('Memory').findByText('60%')).toBeInTheDocument()+ expect(screen.getAllByText('Metric is not supported')).toHaveLength(1)+ expect(card(label).queryByText('0%')).not.toBeInTheDocument()+ expect(requests).toHaveLength(1)+ })++ it('shows every affected card error when all results fail', async () => {+ const requests = mockMetrics('*')+ renderMetrics()+ await waitFor(() => expect(screen.getAllByText('Metric is not supported')).toHaveLength(5))+ expect(requests).toHaveLength(1)+ })++ it('does not display missing series as zero', async () => {+ mockMetrics('disk_io_consumption', false)+ renderMetrics()+ expect(await card('Disk IO').findByText('Error loading data')).toBeInTheDocument()+ expect(await card('CPU').findByText('25%')).toBeInTheDocument()+ })++ it('shows request-wide failures on every infrastructure card', async () => {+ addAPIMock({+ method: 'get',+ path: '/platform/projects/:ref/infra-monitoring',+ response: () =>+ HttpResponse.json<APIErrorBody>({ message: 'Project not found' }, { status: 404 }),+ })+ renderMetrics()+ await waitFor(() => expect(screen.getAllByText('Project not found')).toHaveLength(5))+ })+})diff --git a/apps/studio/components/interfaces/Observability/DatabaseInfrastructureMetric.tsx b/apps/studio/components/interfaces/Observability/DatabaseInfrastructureMetric.tsxnew file mode 100644index 00000000000..edb59f9790e--- /dev/null+++ b/apps/studio/components/interfaces/Observability/DatabaseInfrastructureMetric.tsx@@ -0,0 +1,121 @@+import type { UseQueryResult } from '@tanstack/react-query'+import Link from 'next/link'+import {+ MetricCard,+ MetricCardContent,+ MetricCardHeader,+ MetricCardLabel,+ MetricCardValue,+} from 'ui-patterns/MetricCard'++import {+ parseConnectionsData,+ parseInfrastructureMetrics,+} from './DatabaseInfrastructureSection.utils'+import {+ type InfraMonitoringAttribute,+ type InfraMonitoringError,+ type InfraMonitoringMultiData,+} from '@/data/analytics/infra-monitoring-query'+import type { MaxConnectionsData, MaxConnectionsError } from '@/data/database/max-connections-query'++const METRICS = {+ connections: {+ label: 'Peak Connections',+ tooltip:+ 'Highest concurrent database connections observed in the selected window, against the connection limit. Monitor to avoid connection exhaustion.',+ attributes: ['pg_stat_database_num_backends'],+ },+ disk: {+ label: 'Disk Usage',+ tooltip: 'Disk usage percentage of total disk space used',+ attributes: ['disk_fs_used_system', 'disk_fs_used_wal', 'pg_database_size', 'disk_fs_size'],+ },+ diskIo: {+ label: 'Disk IO',+ tooltip: 'Disk I/O consumption percentage. High values may indicate disk bottlenecks',+ attributes: ['disk_io_consumption'],+ },+ ram: {+ label: 'Memory',+ tooltip: 'RAM usage percentage. Sustained high usage may indicate memory pressure',+ attributes: ['ram_usage'],+ },+ cpu: {+ label: 'CPU',+ tooltip: 'CPU usage percentage. High values may suggest CPU-intensive queries or workloads',+ attributes: ['avg_cpu_usage'],+ },+} satisfies Record<+ string,+ { label: string; tooltip: string; attributes: InfraMonitoringAttribute[] }+>++export const INFRASTRUCTURE_METRIC_ATTRIBUTES = Object.values(METRICS).flatMap(+ ({ attributes }) => attributes+)++type DatabaseInfrastructureMetricProps = {+ infraQuery: Pick<+ UseQueryResult<InfraMonitoringMultiData, InfraMonitoringError>,+ 'data' | 'error' | 'isLoading'+ >+ metric: keyof typeof METRICS+ href: string+ maxConnectionsQuery: Pick<+ UseQueryResult<MaxConnectionsData, MaxConnectionsError>,+ 'data' | 'error' | 'isLoading'+ >+}++export const DatabaseInfrastructureMetric = ({+ metric,+ href,+ maxConnectionsQuery,+ infraQuery,+}: DatabaseInfrastructureMetricProps) => {+ const { label, tooltip, attributes } = METRICS[metric]+ const isConnections = metric === 'connections'+ const isLoading = infraQuery.isLoading || (isConnections && maxConnectionsQuery.isLoading)+ const data = infraQuery.data+ const errors = data && 'errors' in data ? data.errors : undefined+ const metricError = attributes.map((attribute) => errors?.[attribute]).find(Boolean)+ const hasMissingSeries =+ data && 'series' in data && attributes.some((attribute) => !data.series[attribute])+ const error =+ infraQuery.error ??+ metricError ??+ (isConnections ? maxConnectionsQuery.error : null) ??+ (hasMissingSeries ? { message: 'Error loading data' } : null)+ const errorMessage =+ error && typeof error === 'object' && 'message' in error+ ? String(error.message)+ : 'Error loading data'++ let value = '--'+ if (data) {+ if (isConnections) {+ const connections = parseConnectionsData(data, maxConnectionsQuery.data)+ if (connections.max > 0) value = `${connections.peak}/${connections.max}`+ } else {+ const metrics = parseInfrastructureMetrics(data)+ if (metrics) value = `${metrics[metric].current.toFixed(0)}%`+ }+ }++ return (+ <Link href={href} className="block group">+ <MetricCard isLoading={isLoading}>+ <MetricCardHeader linkTooltip="Go to database report">+ <MetricCardLabel tooltip={tooltip}>{label}</MetricCardLabel>+ </MetricCardHeader>+ <MetricCardContent>+ {!!error && (+ <div className="text-xs text-destructive wrap-break-word">{errorMessage}</div>+ )}+ {!error && <MetricCardValue>{value}</MetricCardValue>}+ </MetricCardContent>+ </MetricCard>+ </Link>+ )+}diff --git a/apps/studio/components/interfaces/Observability/DatabaseInfrastructureSection.tsx b/apps/studio/components/interfaces/Observability/DatabaseInfrastructureSection.tsxindex 13c5d8eeb54..0f8cda2c25c 100644--- a/apps/studio/components/interfaces/Observability/DatabaseInfrastructureSection.tsx+++ b/apps/studio/components/interfaces/Observability/DatabaseInfrastructureSection.tsx@@ -11,9 +11,9 @@ import {} from 'ui-patterns/MetricCard'import {- parseConnectionsData,- parseInfrastructureMetrics,-} from './DatabaseInfrastructureSection.utils'+ DatabaseInfrastructureMetric,+ INFRASTRUCTURE_METRIC_ATTRIBUTES,+} from './DatabaseInfrastructureMetric'import { useInfraMonitoringAttributesQuery } from '@/data/analytics/infra-monitoring-query'import { useMaxConnectionsQuery } from '@/data/database/max-connections-query'import { useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'@@ -66,44 +66,19 @@ export const DatabaseInfrastructureSection = ({return { startDate: start, endDate: end, infraInterval }}, [interval, refreshKey])- const {- data: infraData,- isLoading: infraLoading,- error: infraError,- } = useInfraMonitoringAttributesQuery({+ const infraQuery = useInfraMonitoringAttributesQuery({projectRef,- attributes: [- 'avg_cpu_usage',- 'ram_usage',- 'disk_fs_used_system',- 'disk_fs_used_wal',- 'pg_database_size',- 'disk_fs_size',- 'disk_io_consumption',- 'pg_stat_database_num_backends',- ],+ attributes: INFRASTRUCTURE_METRIC_ATTRIBUTES,startDate,endDate,interval: infraInterval,})- const { data: maxConnectionsData } = useMaxConnectionsQuery({+ const maxConnectionsQuery = useMaxConnectionsQuery({projectRef,connectionString: project?.connectionString,})- const metrics = useMemo(() => parseInfrastructureMetrics(infraData), [infraData])-- const connections = useMemo(- () => parseConnectionsData(infraData, maxConnectionsData),- [infraData, maxConnectionsData]- )-- const errorMessage =- infraError && typeof infraError === 'object' && 'message' in infraError- ? String(infraError.message)- : 'Error loading data'-// Generate database report URL with time range parametersconst getDatabaseReportUrl = () => {const now = dayjs()@@ -162,102 +137,15 @@ export const DatabaseInfrastructureSection = ({</MetricCard></Link>- <Link href={databaseReportUrl} className="block group">- <MetricCard isLoading={infraLoading}>- <MetricCardHeader linkTooltip="Go to database report">- <MetricCardLabel tooltip="Highest concurrent database connections observed in the selected window, against the connection limit. Monitor to avoid connection exhaustion.">- Peak Connections- </MetricCardLabel>- </MetricCardHeader>- <MetricCardContent>- {infraError ? (- <div className="text-xs text-destructive wrap-break-word">{errorMessage}</div>- ) : connections.max > 0 ? (- <MetricCardValue>- {connections.peak}/{connections.max}- </MetricCardValue>- ) : (- <MetricCardValue>--</MetricCardValue>- )}- </MetricCardContent>- </MetricCard>- </Link>-- <Link href={databaseReportUrl} className="block group">- <MetricCard isLoading={infraLoading}>- <MetricCardHeader linkTooltip="Go to database report">- <MetricCardLabel tooltip="Disk usage percentage of total disk space used">- Disk Usage- </MetricCardLabel>- </MetricCardHeader>- <MetricCardContent>- {infraError ? (- <div className="text-xs text-destructive wrap-break-word">{errorMessage}</div>- ) : metrics ? (- <MetricCardValue>{metrics.disk.current.toFixed(0)}%</MetricCardValue>- ) : (- <MetricCardValue>--</MetricCardValue>- )}- </MetricCardContent>- </MetricCard>- </Link>-- <Link href={databaseReportUrl} className="block group">- <MetricCard isLoading={infraLoading}>- <MetricCardHeader linkTooltip="Go to database report">- <MetricCardLabel tooltip="Disk I/O consumption percentage. High values may indicate disk bottlenecks">- Disk IO- </MetricCardLabel>- </MetricCardHeader>- <MetricCardContent>- {infraError ? (- <div className="text-xs text-destructive wrap-break-word">{errorMessage}</div>- ) : metrics ? (- <MetricCardValue>{metrics.diskIo.current.toFixed(0)}%</MetricCardValue>- ) : (- <MetricCardValue>--</MetricCardValue>- )}- </MetricCardContent>- </MetricCard>- </Link>-- <Link href={databaseReportUrl} className="block group">- <MetricCard isLoading={infraLoading}>- <MetricCardHeader linkTooltip="Go to database report">- <MetricCardLabel tooltip="RAM usage percentage. Sustained high usage may indicate memory pressure">- Memory- </MetricCardLabel>- </MetricCardHeader>- <MetricCardContent>- {infraError ? (- <div className="text-xs text-destructive wrap-break-word">{errorMessage}</div>- ) : metrics ? (- <MetricCardValue>{metrics.ram.current.toFixed(0)}%</MetricCardValue>- ) : (- <MetricCardValue>--</MetricCardValue>- )}- </MetricCardContent>- </MetricCard>- </Link>-- <Link href={databaseReportUrl} className="block group">- <MetricCard isLoading={infraLoading}>- <MetricCardHeader linkTooltip="Go to database report">- <MetricCardLabel tooltip="CPU usage percentage. High values may suggest CPU-intensive queries or workloads">- CPU- </MetricCardLabel>- </MetricCardHeader>- <MetricCardContent>- {infraError ? (- <div className="text-xs text-destructive wrap-break-word">{errorMessage}</div>- ) : metrics ? (- <MetricCardValue>{metrics.cpu.current.toFixed(0)}%</MetricCardValue>- ) : (- <MetricCardValue>--</MetricCardValue>- )}- </MetricCardContent>- </MetricCard>- </Link>+ {(['connections', 'disk', 'diskIo', 'ram', 'cpu'] as const).map((metric) => (+ <DatabaseInfrastructureMetric+ key={metric}+ metric={metric}+ infraQuery={infraQuery}+ href={databaseReportUrl}+ maxConnectionsQuery={maxConnectionsQuery}+ />+ ))}</div></div>)diff --git a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/ComputeMetricsFooter.tsx b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/ComputeMetricsFooter.tsxindex 4ca4b8d3b43..2250c7d0a84 100644--- a/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/ComputeMetricsFooter.tsx+++ b/apps/studio/components/interfaces/Settings/Infrastructure/InfrastructureConfiguration/ComputeMetricsFooter.tsx@@ -33,10 +33,17 @@ export const ComputeMetricsFooter = ({ showConnections = true }: { showConnectiohref={observabilityUrl}className="border-t px-3 py-2 hover:bg-surface-200 transition flex items-center gap-x-3 text-xs">- {/* Stable live region: announces loading/failure, never the polled values */}+ {/* Stable live region: announces loading/unavailability, never the polled values */}<span role="status" className="sr-only">{isMetricsLoading && 'Loading metrics'}{!isMetricsLoading && isMetricsError && 'Metrics unavailable'}+ {!isMetricsLoading && !isMetricsError && (+ <>+ {cpu === null && 'CPU unavailable. '}+ {disk === null && 'Disk unavailable. '}+ {memory === null && 'RAM unavailable.'}+ </>+ )}</span>{/* h-4 matches the text-xs line height so the card doesn't shift when metrics load */}{isMetricsLoading && (@@ -53,17 +60,17 @@ export const ComputeMetricsFooter = ({ showConnections = true }: { showConnectio{!isMetricsLoading && !isMetricsError && (<><span>- CPU <span className={metricColor(cpu)}>{cpu.toFixed(0)}%</span>+ CPU <MetricValue value={cpu} /></span><span className="text-foreground-lighter">·</span><span>- Disk <span className={metricColor(disk)}>{disk.toFixed(0)}%</span>+ Disk <MetricValue value={disk} /></span><span className="text-foreground-lighter">·</span><span>- RAM <span className={metricColor(memory)}>{memory.toFixed(0)}%</span>+ RAM <MetricValue value={memory} /></span>- {showConnections && connections.max > 0 && (+ {showConnections && connections !== null && connections.max > 0 && (<><span className="text-foreground-lighter">·</span><span className="text-foreground-light">@@ -79,3 +86,11 @@ export const ComputeMetricsFooter = ({ showConnections = true }: { showConnectio</Tooltip>)}++function MetricValue({ value }: { value: number | null }) {+ if (value === null) {+ return <span className="text-foreground-lighter">Unavailable</span>+ }++ return <span className={metricColor(value)}>{value.toFixed(0)}%</span>+}diff --git a/apps/studio/data/analytics/infra-monitoring-queries.test.ts b/apps/studio/data/analytics/infra-monitoring-queries.test.tsindex b8be88aa2f3..504bab80a7d 100644--- a/apps/studio/data/analytics/infra-monitoring-queries.test.ts+++ b/apps/studio/data/analytics/infra-monitoring-queries.test.ts@@ -1,12 +1,20 @@+import { waitFor } from '@testing-library/react'import dayjs from 'dayjs'+import { HttpResponse } from 'msw'import { describe, expect, it } from 'vitest'-import { aggregate1MinTo2Min, mapResponseToAnalyticsData } from './infra-monitoring-queries'+import {+ aggregate1MinTo2Min,+ mapResponseToAnalyticsData,+ useInfraMonitoringQueries,+} from './infra-monitoring-queries'import type {InfraMonitoringMultiData,InfraMonitoringMultiResponse,InfraMonitoringSingleResponse,} from './infra-monitoring-query'+import { customRenderHook } from '@/tests/lib/custom-render'+import { addAPIMock } from '@/tests/lib/msw'const mockMultiResponse: InfraMonitoringMultiResponse = {data: [@@ -500,3 +508,43 @@ describe('aggregate1MinTo2Min', () => {expect(typeof result[0].periodStartFormatted).toBe('string')})})++describe('useInfraMonitoringQueries partial failures', () => {+ it('reports errors only for failed attributes in a successful batch response', async () => {+ addAPIMock({+ method: 'get',+ path: '/platform/projects/:ref/infra-monitoring',+ response: () =>+ HttpResponse.json<InfraMonitoringMultiResponse>({+ ...mockMultiResponse,+ series: { ram_usage: mockMultiResponse.series.ram_usage },+ errors: { max_cpu_usage: { message: 'CPU unavailable' } },+ }),+ })+ const { result } = customRenderHook(() =>+ useInfraMonitoringQueries(+ ['max_cpu_usage', 'ram_usage'],+ 'default',+ '2024-01-02T00:00:00Z',+ '2024-01-03T00:00:00Z',+ '1h',+ undefined,+ undefined,+ true+ )+ )++ await waitFor(() => expect(result.current[1].status).toBe('success'))+ expect(result.current[0]).toMatchObject({+ data: undefined,+ error: { message: 'CPU unavailable' },+ isError: true,+ status: 'error',+ })+ expect(result.current[1]).toMatchObject({+ error: null,+ isError: false,+ data: { total: 3 },+ })+ })+})diff --git a/apps/studio/data/analytics/infra-monitoring-queries.ts b/apps/studio/data/analytics/infra-monitoring-queries.tsindex 6c58dc24906..2d1ad996a18 100644--- a/apps/studio/data/analytics/infra-monitoring-queries.ts+++ b/apps/studio/data/analytics/infra-monitoring-queries.ts@@ -66,14 +66,18 @@ export function useInfraMonitoringQueries(return []}- return attributes.map<InfraQueryResult>((attribute) => ({- data: seriesByAttribute?.[attribute],- error: query.error,- isError: query.isError,- isFetching: query.isFetching,- isLoading: query.isLoading,- status: query.status,- }))+ return attributes.map<InfraQueryResult>((attribute) => {+ const metricError =+ query.data && 'errors' in query.data ? query.data.errors?.[attribute] : undefined+ return {+ data: seriesByAttribute?.[attribute],+ error: query.error ?? metricError ?? null,+ isError: query.isError || !!metricError,+ isFetching: query.isFetching,+ isLoading: query.isLoading,+ status: metricError ? 'error' : query.status,+ }+ })}type AggregatedBucket = {diff --git a/apps/studio/data/analytics/infra-monitoring-query.ts b/apps/studio/data/analytics/infra-monitoring-query.tsindex fe4b5fcdabe..69846bb3195 100644--- a/apps/studio/data/analytics/infra-monitoring-query.ts+++ b/apps/studio/data/analytics/infra-monitoring-query.ts@@ -33,6 +33,7 @@ export type InfraMonitoringMultiResponse = {values: Record<string, string | undefined>}[]series: Record<string, InfraMonitoringSeriesMetadata>+ errors?: Record<string, { message: string }>}// TODO(raulb): Simplify to just InfraMonitoringMultiResponse once API always returns multi-attribute format.diff --git a/apps/studio/hooks/analytics/useComputeMetrics.ts b/apps/studio/hooks/analytics/useComputeMetrics.tsindex 63e3a5ba620..6f716e12849 100644--- a/apps/studio/hooks/analytics/useComputeMetrics.ts+++ b/apps/studio/hooks/analytics/useComputeMetrics.ts@@ -1,6 +1,7 @@import dayjs from 'dayjs'import { useMemo } from 'react'+import { COMPUTE_METRICS_ATTRIBUTES, getComputeMetricAvailability } from './useComputeMetrics.utils'import {parseConnectionsData,parseInfrastructureMetrics,@@ -10,10 +11,10 @@ import { useMaxConnectionsQuery } from '@/data/database/max-connections-query'import { useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'export type ComputeMetrics = {- cpu: number- disk: number- memory: number- connections: { peak: number; max: number }+ cpu: number | null+ disk: number | null+ memory: number | null+ connections: { peak: number; max: number } | nullisLoading: booleanisError: boolean}@@ -37,21 +38,17 @@ export function useComputeMetrics({ projectRef }: { projectRef?: string }): CompisError,} = useInfraMonitoringAttributesQuery({projectRef,- attributes: [- 'avg_cpu_usage',- 'ram_usage',- 'disk_fs_used_system',- 'disk_fs_used_wal',- 'pg_database_size',- 'disk_fs_size',- 'pg_stat_database_num_backends',- ],+ attributes: COMPUTE_METRICS_ATTRIBUTES,startDate,endDate,interval: '1h',})- const { data: maxConnectionsData, isLoading: connectionsLoading } = useMaxConnectionsQuery({+ const {+ data: maxConnectionsData,+ isLoading: connectionsLoading,+ isError: isConnectionsError,+ } = useMaxConnectionsQuery({projectRef,connectionString: project?.connectionString,})@@ -61,12 +58,13 @@ export function useComputeMetrics({ projectRef }: { projectRef?: string }): Comp() => parseConnectionsData(infraData, maxConnectionsData),[infraData, maxConnectionsData])+ const availability = getComputeMetricAvailability(infraData)return {- cpu: metrics?.cpu.current ?? 0,- disk: metrics?.disk.current ?? 0,- memory: metrics?.ram.current ?? 0,- connections,+ cpu: availability.cpu ? (metrics?.cpu.current ?? null) : null,+ disk: availability.disk ? (metrics?.disk.current ?? null) : null,+ memory: availability.memory ? (metrics?.ram.current ?? null) : null,+ connections: availability.connections && !isConnectionsError ? connections : null,isLoading: infraLoading || connectionsLoading,isError,}diff --git a/apps/studio/hooks/analytics/useComputeMetrics.utils.ts b/apps/studio/hooks/analytics/useComputeMetrics.utils.tsnew file mode 100644index 00000000000..c411933cd98--- /dev/null+++ b/apps/studio/hooks/analytics/useComputeMetrics.utils.ts@@ -0,0 +1,27 @@+import type {+ InfraMonitoringAttribute,+ InfraMonitoringResponse,+} from '@/data/analytics/infra-monitoring-query'++const COMPUTE_METRIC_ATTRIBUTES = {+ cpu: ['avg_cpu_usage'],+ memory: ['ram_usage'],+ disk: ['disk_fs_used_system', 'disk_fs_used_wal', 'pg_database_size', 'disk_fs_size'],+ connections: ['pg_stat_database_num_backends'],+} satisfies Record<string, InfraMonitoringAttribute[]>++export const COMPUTE_METRICS_ATTRIBUTES = Object.values(COMPUTE_METRIC_ATTRIBUTES).flat()++export function getComputeMetricAvailability(data: InfraMonitoringResponse | undefined) {+ const hasMetricData = (attributes: InfraMonitoringAttribute[]) =>+ !!data &&+ 'series' in data &&+ attributes.every((attribute) => !!data.series[attribute] && !data.errors?.[attribute])++ return {+ cpu: hasMetricData(COMPUTE_METRIC_ATTRIBUTES.cpu),+ memory: hasMetricData(COMPUTE_METRIC_ATTRIBUTES.memory),+ disk: hasMetricData(COMPUTE_METRIC_ATTRIBUTES.disk),+ connections: hasMetricData(COMPUTE_METRIC_ATTRIBUTES.connections),+ }+}diff --git a/apps/studio/tests/hooks/analytics/useComputeMetrics.utils.test.ts b/apps/studio/tests/hooks/analytics/useComputeMetrics.utils.test.tsnew file mode 100644index 00000000000..8b224201467--- /dev/null+++ b/apps/studio/tests/hooks/analytics/useComputeMetrics.utils.test.ts@@ -0,0 +1,75 @@+import { describe, expect, it } from 'vitest'++import type { InfraMonitoringMultiResponse } from '@/data/analytics/infra-monitoring-query'+import {+ COMPUTE_METRICS_ATTRIBUTES,+ getComputeMetricAvailability,+} from '@/hooks/analytics/useComputeMetrics.utils'++function createMetricsResponse(): InfraMonitoringMultiResponse {+ return {+ data: [],+ series: Object.fromEntries(+ COMPUTE_METRICS_ATTRIBUTES.map((attribute) => [+ attribute,+ { yAxisLimit: 100, format: '', total: 0, totalAverage: 0 },+ ])+ ),+ }+}++const allAvailable = { cpu: true, memory: true, disk: true, connections: true }++describe('getComputeMetricAvailability', () => {+ it('keeps successful zero values available', () => {+ expect(getComputeMetricAvailability(createMetricsResponse())).toEqual(allAvailable)+ })++ it.each([+ ['avg_cpu_usage', 'cpu'],+ ['ram_usage', 'memory'],+ ['disk_fs_used_system', 'disk'],+ ['disk_fs_used_wal', 'disk'],+ ['pg_database_size', 'disk'],+ ['disk_fs_size', 'disk'],+ ['pg_stat_database_num_backends', 'connections'],+ ])(+ 'only marks the affected metric unavailable when %s fails or is missing',+ (attribute, metric) => {+ const response = createMetricsResponse()+ response.errors = { [attribute]: { message: 'Failed to load attribute' } }+ expect(getComputeMetricAvailability(response)).toEqual({ ...allAvailable, [metric]: false })++ delete response.errors+ delete response.series[attribute]+ expect(getComputeMetricAvailability(response)).toEqual({ ...allAvailable, [metric]: false })+ }+ )++ it('ignores errors for unrelated attributes', () => {+ const response = createMetricsResponse()+ response.errors = { disk_io_consumption: { message: 'Failed to load attribute' } }+ expect(getComputeMetricAvailability(response)).toEqual(allAvailable)+ })++ it.each([undefined, { data: [], series: {} }])('handles absent metrics', (response) => {+ expect(getComputeMetricAvailability(response)).toEqual({+ cpu: false,+ memory: false,+ disk: false,+ connections: false,+ })+ })++ it('handles a response without multi-attribute series', () => {+ expect(+ getComputeMetricAvailability({+ data: [],+ yAxisLimit: 100,+ format: '',+ total: 0,+ totalAverage: 0,+ })+ ).toEqual({ cpu: false, memory: false, disk: false, connections: false })+ })+})