Skip to content

The Postgres development platform. Supabase gives you a dedicated Postgres database to build your web, mobile, and AI applications.

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.ts
new file mode 100644
index 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.ts
index 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 } = activity
if (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.tsx
index 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(
{