The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.
TypeScript aialternativeauthdatabasedenoembeddingsexamplefirebasenextjsoauth2pgvectorpostgispostgrespostgresqlpostgrestrealtimesupabasevectorswebsockets
Clean up + add unit tests for database connections (#48372)
Joshen Lim098782467430
diff --git a/apps/studio/components/interfaces/Observability/DatabaseConnections/DatabaseConnections.utils.test.ts b/apps/studio/components/interfaces/Observability/DatabaseConnections/DatabaseConnections.utils.test.tsnew file mode 100644index 00000000000..243b7d053e9--- /dev/null+++ b/apps/studio/components/interfaces/Observability/DatabaseConnections/DatabaseConnections.utils.test.ts@@ -0,0 +1,219 @@+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'++import { getConnectionMetrics } from './DatabaseConnections.utils'+import { type DatabaseActivity } from '@/data/database/activity-query'++const NOW = '2024-01-15T12:00:00Z'++const secondsAgo = (seconds: number) =>+ new Date(new Date(NOW).getTime() - seconds * 1000).toISOString()++// `DatabaseActivity` intersects a discriminated `WaitEvent` union, so `Partial<DatabaseActivity>`+// doesn't distribute cleanly over it - scope overrides to the plain fields tests actually vary.+type ActivityOverrides = Partial<+ Pick<+ DatabaseActivity,+ | 'pid'+ | 'role_name'+ | 'application_name'+ | 'blocked_by'+ | 'query'+ | 'query_start'+ | 'transaction_start'+ | 'state_change'+ | 'state'+ >+>++const activity = (overrides: ActivityOverrides = {}): DatabaseActivity => ({+ pid: 1,+ role_name: 'postgres',+ application_name: 'test',+ blocked_by: [],+ query: 'select 1',+ query_start: null,+ transaction_start: null,+ state_change: null,+ state: 'active',+ wait_event_type: null,+ wait_event: null,+ ...overrides,+})++describe('getConnectionMetrics', () => {+ beforeEach(() => {+ vi.useFakeTimers()+ vi.setSystemTime(new Date(NOW))+ })++ afterEach(() => {+ vi.useRealTimers()+ })++ it('returns empty/null metrics for no activity', () => {+ const metrics = getConnectionMetrics([])++ expect(metrics.activeQueries).toEqual([])+ expect(metrics.blockedQueries).toEqual([])+ expect(metrics.warnBlockedQueries).toBe(false)+ expect(metrics.longestBlockedQuery).toBe(null)+ expect(metrics.idleInTransactionQueries).toEqual([])+ expect(metrics.longestRunningQuery).toBe(null)+ expect(metrics.warnLongestRunningQuery).toBe(false)+ expect(metrics.queryBlockingTheMostQueries).toBe(null)+ expect(metrics.warnTopBlocker).toBe(false)+ })++ it('counts active queries', () => {+ const activities = [+ activity({ pid: 1, state: 'active' }),+ activity({ pid: 2, state: 'idle' }),+ activity({ pid: 3, state: 'active' }),+ ]++ expect(getConnectionMetrics(activities).activeQueries).toHaveLength(2)+ })++ describe('blocked queries', () => {+ it('collects queries that are blocked by another pid', () => {+ const activities = [+ activity({ pid: 1, blocked_by: [2] }),+ activity({ pid: 2, blocked_by: [] }),+ ]++ const { blockedQueries } = getConnectionMetrics(activities)+ expect(blockedQueries.map((a) => a.pid)).toEqual([1])+ })++ it('does not warn when blocked under the threshold (10s)', () => {+ const activities = [+ activity({ pid: 1, state: 'active', blocked_by: [2], query_start: secondsAgo(5) }),+ ]++ expect(getConnectionMetrics(activities).warnBlockedQueries).toBe(false)+ })++ it('warns once a blocked query crosses the threshold (10s)', () => {+ const activities = [+ activity({ pid: 1, state: 'active', blocked_by: [2], query_start: secondsAgo(11) }),+ ]++ expect(getConnectionMetrics(activities).warnBlockedQueries).toBe(true)+ })++ it('picks the longest-blocked query', () => {+ const activities = [+ activity({ pid: 1, state: 'active', blocked_by: [3], query_start: secondsAgo(5) }),+ activity({ pid: 2, state: 'active', blocked_by: [3], query_start: secondsAgo(20) }),+ ]++ const { longestBlockedQuery } = getConnectionMetrics(activities)+ expect(longestBlockedQuery?.activity.pid).toBe(2)+ expect(longestBlockedQuery?.duration).toBe(20)+ })+ })++ describe('idle in transaction', () => {+ it('does not flag idle-in-transaction queries under the threshold (10s)', () => {+ const activities = [+ activity({ pid: 1, state: 'idle in transaction', transaction_start: secondsAgo(5) }),+ ]++ expect(getConnectionMetrics(activities).idleInTransactionQueries).toEqual([])+ })++ it('flags idle-in-transaction (and aborted) queries over the threshold (10s)', () => {+ const activities = [+ activity({ pid: 1, state: 'idle in transaction', transaction_start: secondsAgo(11) }),+ activity({+ pid: 2,+ state: 'idle in transaction (aborted)',+ transaction_start: secondsAgo(11),+ }),+ activity({ pid: 3, state: 'active', query_start: secondsAgo(11) }),+ ]++ const { idleInTransactionQueries } = getConnectionMetrics(activities)+ expect(idleInTransactionQueries.map((a) => a.pid)).toEqual([1, 2])+ })+ })++ describe('longest running query', () => {+ it('ignores states outside active/idle-in-transaction', () => {+ const activities = [activity({ pid: 1, state: 'idle', state_change: secondsAgo(1000) })]++ expect(getConnectionMetrics(activities).longestRunningQuery).toBe(null)+ })++ it('picks the longest-running query among active/idle-in-transaction states', () => {+ const activities = [+ activity({ pid: 1, state: 'active', query_start: secondsAgo(5) }),+ activity({+ pid: 2,+ state: 'idle in transaction',+ transaction_start: secondsAgo(15),+ }),+ ]++ const { longestRunningQuery } = getConnectionMetrics(activities)+ expect(longestRunningQuery?.activity.pid).toBe(2)+ expect(longestRunningQuery?.duration).toBe(15)+ })++ it('warns for an active query past the active threshold (30s)', () => {+ const activities = [activity({ pid: 1, state: 'active', query_start: secondsAgo(31) })]++ expect(getConnectionMetrics(activities).warnLongestRunningQuery).toBe(true)+ })++ it('does not warn for an active query under the active threshold (30s)', () => {+ const activities = [activity({ pid: 1, state: 'active', query_start: secondsAgo(29) })]++ expect(getConnectionMetrics(activities).warnLongestRunningQuery).toBe(false)+ })++ it('warns for an idle-in-transaction query past the shorter idle threshold (10s)', () => {+ const activities = [+ activity({ pid: 1, state: 'idle in transaction', transaction_start: secondsAgo(11) }),+ ]++ expect(getConnectionMetrics(activities).warnLongestRunningQuery).toBe(true)+ })+ })++ describe('top blocker', () => {+ it('picks the pid blocking the most other queries', () => {+ const activities = [+ activity({ pid: 1, blocked_by: [] }),+ activity({ pid: 2, blocked_by: [1] }),+ activity({ pid: 3, blocked_by: [1] }),+ activity({ pid: 4, blocked_by: [1] }),+ activity({ pid: 5, blocked_by: [2] }),+ ]++ const { queryBlockingTheMostQueries } = getConnectionMetrics(activities)+ expect(queryBlockingTheMostQueries?.activity.pid).toBe(1)+ expect(queryBlockingTheMostQueries?.count).toBe(3)+ })++ it('does not warn when the top blocker is under the threshold (3)', () => {+ const activities = [+ activity({ pid: 1, blocked_by: [] }),+ activity({ pid: 2, blocked_by: [1] }),+ ]++ expect(getConnectionMetrics(activities).warnTopBlocker).toBe(false)+ })++ it('warns once the top blocker meets the threshold (3)', () => {+ const activities = [+ activity({ pid: 1, blocked_by: [] }),+ activity({ pid: 2, blocked_by: [1] }),+ activity({ pid: 3, blocked_by: [1] }),+ activity({ pid: 4, blocked_by: [1] }),+ ]++ expect(getConnectionMetrics(activities).warnTopBlocker).toBe(true)+ })+ })+})diff --git a/apps/studio/components/interfaces/Observability/DatabaseConnections/DatabaseConnections.utils.ts b/apps/studio/components/interfaces/Observability/DatabaseConnections/DatabaseConnections.utils.tsindex 81457f80a89..5d00de6a126 100644--- a/apps/studio/components/interfaces/Observability/DatabaseConnections/DatabaseConnections.utils.ts+++ b/apps/studio/components/interfaces/Observability/DatabaseConnections/DatabaseConnections.utils.ts@@ -1,7 +1,33 @@import dayjs from 'dayjs'+import {+ WARN_DURATION_ACTIVE_QUERY,+ WARN_DURATION_BLOCKED,+ WARN_DURATION_IDLE_TXN,+ WARN_TOP_BLOCKER,+} from './DatabaseConnections.constants'import { type DatabaseActivity } from '@/data/database/activity-query'+const LONG_RUNNING_STATES: (DatabaseActivity['state'] | undefined)[] = [+ 'active',+ 'idle in transaction',+ 'idle in transaction (aborted)',+]++type ActivityWithDuration = { activity: DatabaseActivity; duration: number }++export type ConnectionMetrics = {+ activeQueries: DatabaseActivity[]+ blockedQueries: DatabaseActivity[]+ warnBlockedQueries: boolean+ longestBlockedQuery: ActivityWithDuration | null+ idleInTransactionQueries: DatabaseActivity[]+ longestRunningQuery: ActivityWithDuration | null+ warnLongestRunningQuery: boolean+ queryBlockingTheMostQueries: { activity: DatabaseActivity; count: number } | null+ warnTopBlocker: boolean+}+export const getDuration = (activity: DatabaseActivity) => {const { state } = activityif (state === 'active' && activity.query_start) {@@ -38,3 +64,80 @@ export const getActivityStart = (activity: DatabaseActivity) => {}return null}++// Finds the activity with the largest duration-since-start among the given activities (e.g. the+// longest-blocked query, or the longest-running query).+const findLongestRunning = (+ activities: DatabaseActivity[],+ now: dayjs.Dayjs+): ActivityWithDuration | null =>+ activities.reduce<ActivityWithDuration | null>((longest, activity) => {+ const start = getActivityStart(activity)+ if (!start) return longest+ const duration = Math.max(now.diff(dayjs(start).utc(), 'second'), 0)+ return longest === null || duration > longest.duration ? { activity, duration } : longest+ }, null)++// Derives the Overview page's connection/activity metrics (and their warning thresholds) from the+// raw pg_stat_activity rows, so the logic can be unit tested independently of the component.+export const getConnectionMetrics = (activities: DatabaseActivity[]): ConnectionMetrics => {+ // Computed once so every metric below is measured against the same instant, rather than each+ // drifting slightly against the others.+ const now = dayjs().utc()++ const activeQueries = activities.filter((x) => x.state === 'active')++ const blockedQueries = activities.filter((x) => x.blocked_by.length > 0)+ const warnBlockedQueries = blockedQueries.some((activity) => {+ const start = getActivityStart(activity)+ if (!start) return false+ return now.diff(dayjs(start).utc(), 'second') >= WARN_DURATION_BLOCKED+ })+ const longestBlockedQuery = findLongestRunning(blockedQueries, now)++ const idleInTransactionQueries = activities.filter((x) => {+ const isIdleInTransaction =+ x.state === 'idle in transaction' || x.state === 'idle in transaction (aborted)'+ if (!isIdleInTransaction || !x.transaction_start) return false+ return now.diff(dayjs(x.transaction_start).utc(), 'second') >= WARN_DURATION_IDLE_TXN+ })++ const longestRunningQuery = findLongestRunning(+ activities.filter((x) => LONG_RUNNING_STATES.includes(x.state)),+ now+ )+ const warnLongestRunningQuery =+ (longestRunningQuery?.activity.state === 'active' &&+ longestRunningQuery.duration >= WARN_DURATION_ACTIVE_QUERY) ||+ ((longestRunningQuery?.activity.state === 'idle in transaction' ||+ longestRunningQuery?.activity.state === 'idle in transaction (aborted)') &&+ longestRunningQuery.duration >= WARN_DURATION_IDLE_TXN)++ const blockingCounts = activities.reduce<Map<number, number>>((counts, activity) => {+ activity.blocked_by.forEach((pid) => counts.set(pid, (counts.get(pid) ?? 0) + 1))+ return counts+ }, new Map())++ const queryBlockingTheMostQueries = [...blockingCounts].reduce<{+ activity: DatabaseActivity+ count: number+ } | null>((mostBlocking, [pid, count]) => {+ if (mostBlocking && count <= mostBlocking.count) return mostBlocking+ const activity = activities.find((x) => x.pid === pid)+ return activity ? { activity, count } : mostBlocking+ }, null)++ const warnTopBlocker = (queryBlockingTheMostQueries?.count ?? 0) >= WARN_TOP_BLOCKER++ return {+ activeQueries,+ blockedQueries,+ warnBlockedQueries,+ longestBlockedQuery,+ idleInTransactionQueries,+ longestRunningQuery,+ warnLongestRunningQuery,+ queryBlockingTheMostQueries,+ warnTopBlocker,+ }+}diff --git a/apps/studio/components/interfaces/Observability/DatabaseConnections/Overview.tsx b/apps/studio/components/interfaces/Observability/DatabaseConnections/Overview.tsxindex 375aa984c77..d98ccc507c5 100644--- a/apps/studio/components/interfaces/Observability/DatabaseConnections/Overview.tsx+++ b/apps/studio/components/interfaces/Observability/DatabaseConnections/Overview.tsx@@ -1,4 +1,3 @@-import dayjs from 'dayjs'import { parseAsInteger, useQueryState } from 'nuqs'import { cn } from 'ui'import {@@ -9,25 +8,13 @@ import {MetricCardValue,} from 'ui-patterns/MetricCard'-import {- WARN_DURATION_ACTIVE_QUERY,- WARN_DURATION_BLOCKED,- WARN_DURATION_IDLE_TXN,- WARN_TOP_BLOCKER,-} from './DatabaseConnections.constants'-import { getActivityStart } from './DatabaseConnections.utils'+import { getConnectionMetrics } from './DatabaseConnections.utils'import { formatDuration } from '@/components/interfaces/QueryPerformance/QueryPerformance.utils'import { useDatabaseRolesQuery } from '@/data/database-roles/database-roles-query'-import { useDatabaseActivityQuery, type DatabaseActivity } from '@/data/database/activity-query'+import { useDatabaseActivityQuery } from '@/data/database/activity-query'import { useMaxConnectionsQuery } from '@/data/database/max-connections-query'import { useSelectedProjectQuery } from '@/hooks/misc/useSelectedProject'-const LONG_RUNNING_STATES: (DatabaseActivity['state'] | undefined)[] = [- 'active',- 'idle in transaction',- 'idle in transaction (aborted)',-]-interface OverviewProps {live?: boolean}@@ -43,61 +30,18 @@ export const Overview = ({ live }: OverviewProps) => {},{ refetchOnWindowFocus: live, refetchInterval: live ? 3000 : false })- const activeQueries = (data ?? []).filter((x) => x.state === 'active')-- const blockedQueries = (data ?? []).filter((x) => x.blocked_by.length > 0)- const warnBlockedQueries = blockedQueries.some((activity) => {- const start = getActivityStart(activity)- if (!start) return false- return dayjs().utc().diff(dayjs(start).utc(), 'second') >= WARN_DURATION_BLOCKED- })- const longestBlockedQuery = blockedQueries.reduce<{- activity: DatabaseActivity- duration: number- } | null>((longest, activity) => {- const start = getActivityStart(activity)- if (!start) return longest- const duration = Math.max(dayjs().utc().diff(dayjs(start).utc(), 'second'), 0)- return longest === null || duration > longest.duration ? { activity, duration } : longest- }, null)-- const idleInTransactionQueries = (data ?? []).filter((x) => {- const isIdleInTransaction =- x.state === 'idle in transaction' || x.state === 'idle in transaction (aborted)'- if (!isIdleInTransaction || !x.transaction_start) return false- return dayjs().utc().diff(dayjs(x.transaction_start).utc(), 'second') > WARN_DURATION_IDLE_TXN- })-- const longestRunningQuery = (data ?? [])- .filter((x) => LONG_RUNNING_STATES.includes(x.state))- .reduce<{ activity: DatabaseActivity; duration: number } | null>((longest, activity) => {- const start = getActivityStart(activity)- if (!start) return longest- const duration = Math.max(dayjs().utc().diff(dayjs(start).utc(), 'second'), 0)- return longest === null || duration > longest.duration ? { activity, duration } : longest- }, null)- const warnLongestRunningQuery =- (longestRunningQuery?.activity.state === 'active' &&- longestRunningQuery.duration >= WARN_DURATION_ACTIVE_QUERY) ||- ((longestRunningQuery?.activity.state === 'idle in transaction' ||- longestRunningQuery?.activity.state === 'idle in transaction (aborted)') &&- longestRunningQuery.duration >= WARN_DURATION_IDLE_TXN)-- const blockingCounts = (data ?? []).reduce<Map<number, number>>((counts, activity) => {- activity.blocked_by.forEach((pid) => counts.set(pid, (counts.get(pid) ?? 0) + 1))- return counts- }, new Map())-- const queryBlockingTheMostQueries = [...blockingCounts].reduce<{- activity: DatabaseActivity- count: number- } | null>((mostBlocking, [pid, count]) => {- if (mostBlocking && count <= mostBlocking.count) return mostBlocking- const activity = (data ?? []).find((x) => x.pid === pid)- return activity ? { activity, count } : mostBlocking- }, null)- const warnTopBlocker = (queryBlockingTheMostQueries?.count ?? 0) >= WARN_TOP_BLOCKER+ const {+ activeQueries,+ blockedQueries,+ warnBlockedQueries,+ longestBlockedQuery,+ idleInTransactionQueries,+ longestRunningQuery,+ warnLongestRunningQuery,+ queryBlockingTheMostQueries,+ warnTopBlocker,+ } = getConnectionMetrics(data ?? [])const { data: roles, isPending: isLoadingRoles } = useDatabaseRolesQuery({