Skip to content

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

feat(studio): migrate API reports to OTEL (#50638)

Jordi Enricd6ca0e590030
diff --git a/apps/studio/components/interfaces/Reports/Reports.constants.otel.test.ts b/apps/studio/components/interfaces/Reports/Reports.constants.otel.test.ts
index 34e6f2857dd..59ef8cdf5f3 100644
--- a/apps/studio/components/interfaces/Reports/Reports.constants.otel.test.ts
+++ b/apps/studio/components/interfaces/Reports/Reports.constants.otel.test.ts
@@ -51,7 +51,7 @@ describe('generateOtelWhereSafe', () => {
})
})
-describe('Storage report OTEL queries', () => {
+describe('Report OTEL queries', () => {
it.each([
['totalRequests', 50000],
['topRoutes', 10],
@@ -60,6 +60,7 @@ describe('Storage report OTEL queries', () => {
['responseSpeed', 50000],
['topSlowRoutes', 10],
['networkTraffic', 50000],
+ ['requestsByCountry', 250],
])('uses edge_logs and a fixed limit for API query %s', (queryName, limit) => {
const sql = getOtelSql(Presets.API, queryName)
@@ -87,6 +88,7 @@ describe('Storage report OTEL queries', () => {
const routesSql = getOtelSql(Presets.API, 'topRoutes')
const speedSql = getOtelSql(Presets.API, 'responseSpeed')
const trafficSql = getOtelSql(Presets.API, 'networkTraffic')
+ const countrySql = getOtelSql(Presets.API, 'requestsByCountry')
expect(routesSql).toContain("log_attributes['request.path'] as path")
expect(routesSql).toContain("log_attributes['request.method'] as method")
@@ -104,6 +106,8 @@ describe('Storage report OTEL queries', () => {
expect(trafficSql).toContain(
"sum(toFloat64OrZero(log_attributes['response.headers.content_length'])) / 1000000 as egress_mb"
)
+ expect(countrySql).toContain("log_attributes['request.cf.country'] as country")
+ expect(countrySql).toContain("notEmpty(log_attributes['request.cf.country'])")
})
it('builds numeric Storage cache results from exact OTEL attributes', () => {
diff --git a/apps/studio/components/interfaces/Reports/Reports.constants.ts b/apps/studio/components/interfaces/Reports/Reports.constants.ts
index 2bea60fc78a..e0c0b35e5ca 100644
--- a/apps/studio/components/interfaces/Reports/Reports.constants.ts
+++ b/apps/studio/components/interfaces/Reports/Reports.constants.ts
@@ -477,6 +477,15 @@ export const PRESET_CONFIG: Record<Presets, PresetConfig> = {
group by
cf.country
`,
+ safeSqlOtel: (filters) => safeLogSql`
+ select
+ log_attributes['request.cf.country'] as country,
+ toFloat64(count()) as count
+ from logs
+ ${otelWhere(filters, safeLogSql`notEmpty(log_attributes['request.cf.country'])`)}
+ group by country
+ order by count desc
+ limit 250`,
},
},
},
diff --git a/apps/studio/components/interfaces/Reports/SharedAPIReport/SharedAPIReport.constants.ts b/apps/studio/components/interfaces/Reports/SharedAPIReport/SharedAPIReport.constants.ts
index 06d3ca0e3da..722fbb450fa 100644
--- a/apps/studio/components/interfaces/Reports/SharedAPIReport/SharedAPIReport.constants.ts
+++ b/apps/studio/components/interfaces/Reports/SharedAPIReport/SharedAPIReport.constants.ts
@@ -1,13 +1,17 @@
import * as Sentry from '@sentry/nextjs'
import { useQueries, useQueryClient } from '@tanstack/react-query'
-import { useParams } from 'common'
+import { FeatureFlagContext, useFlag, useParams } from 'common'
import { isEqual } from 'lodash'
-import { useState } from 'react'
+import { useContext, useState } from 'react'
-import { generateRegexpWhereSafe } from '../Reports.constants'
+import { generateRegexpWhereSafe, PRESET_CONFIG } from '../Reports.constants'
import { ReportFilterItem } from '../Reports.types'
+import { getLogsSql } from '../Reports.utils'
import { executeAnalyticsSql } from '@/data/logs/execute-analytics-sql'
+import { logsAllEndpointUrl } from '@/data/logs/logs-endpoint'
import { safeSql, type SafeLogSqlFragment } from '@/data/logs/safe-analytics-sql'
+import { reportKeys } from '@/data/reports/keys'
+import { IS_PLATFORM } from '@/lib/constants'
const SOURCE_TABLE: Record<string, SafeLogSqlFragment> = {
edge_logs: safeSql`edge_logs`,
@@ -200,8 +204,6 @@ export const SHARED_API_REPORT_SQL = {
export type SharedAPIReportKey = keyof typeof SHARED_API_REPORT_SQL
-const DEFAULT_KEYS = ['shared-api-report']
-
export type SharedAPIReportFilterBy =
| 'auth'
| 'realtime'
@@ -209,6 +211,7 @@ export type SharedAPIReportFilterBy =
| 'graphql'
| 'functions'
| 'postgrest'
+
type SharedAPIReportParams = {
filterBy: SharedAPIReportFilterBy
start: string
@@ -225,6 +228,8 @@ export const useSharedAPIReport = ({
const { ref } = useParams() as { ref: string }
const [filters, setFilters] = useState<ReportFilterItem[]>([])
const queryClient = useQueryClient()
+ const flagUseOtel = useFlag('otelReports')
+ const { hasLoaded: hasLoadedFlags } = useContext(FeatureFlagContext)
const filterByMapSource = {
functions: 'function_edge_logs',
realtime: 'edge_logs',
@@ -250,31 +255,53 @@ export const useSharedAPIReport = ({
}
const allFilters = [baseFilter, ...filters]
+ const source = filterByMapSource[filterBy]
+ const isDataApiReport = filterBy === 'postgrest'
+ const useOtel = IS_PLATFORM && isDataApiReport && Boolean(flagUseOtel)
+ const isQueryModeReady = !IS_PLATFORM || !isDataApiReport || hasLoadedFlags === true
+ const keys = Object.keys(SHARED_API_REPORT_SQL) as SharedAPIReportKey[]
+ const getQuerySql = (queryName: SharedAPIReportKey) =>
+ useOtel
+ ? getLogsSql(PRESET_CONFIG.api.queries[queryName], allFilters, true)
+ : SHARED_API_REPORT_SQL[queryName].safeSql(allFilters, source)
+ const SQLMap: Record<SharedAPIReportKey, SafeLogSqlFragment> = {
+ totalRequests: getQuerySql('totalRequests'),
+ topRoutes: getQuerySql('topRoutes'),
+ errorCounts: getQuerySql('errorCounts'),
+ topErrorRoutes: getQuerySql('topErrorRoutes'),
+ responseSpeed: getQuerySql('responseSpeed'),
+ topSlowRoutes: getQuerySql('topSlowRoutes'),
+ networkTraffic: getQuerySql('networkTraffic'),
+ }
const queries = useQueries({
- queries: Object.entries(SHARED_API_REPORT_SQL).map(([key, value]) => ({
- queryKey: [
- ...DEFAULT_KEYS,
+ queries: keys.map((queryName) => ({
+ queryKey: reportKeys.sharedApiMetric({
filterBy,
- key,
- filterByMapSource[filterBy],
+ queryName,
+ source,
filters,
start,
end,
- ref,
- ],
- enabled: enabled && !!ref && !!filterBy,
- queryFn: async () => {
+ projectRef: ref,
+ useOtel,
+ }),
+ enabled: enabled && isQueryModeReady && !!ref && !!filterBy,
+ queryFn: async ({ signal }) => {
try {
const data = await executeAnalyticsSql({
projectRef: ref,
- endpoint: '/platform/projects/{ref}/analytics/endpoints/logs.all',
- sql: value.safeSql(allFilters, filterByMapSource[filterBy]),
+ endpoint: logsAllEndpointUrl(useOtel),
+ sql: SQLMap[queryName],
iso_timestamp_start: start,
iso_timestamp_end: end,
method: 'get',
+ signal,
})
- if (data?.error) throw data.error
+ if (data?.error !== undefined) {
+ const message = typeof data.error === 'string' ? data.error : data.error.message
+ throw new Error(message)
+ }
return data
} catch (err) {
Sentry.captureException({ message: 'Shared API Report Error', data: { error: err } })
@@ -284,8 +311,6 @@ export const useSharedAPIReport = ({
})),
})
- const keys = Object.keys(SHARED_API_REPORT_SQL) as Array<keyof typeof SHARED_API_REPORT_SQL>
-
const data = keys.reduce(
(acc, key, i) => {
acc[key] = queries[i].data?.result || []
@@ -296,15 +321,15 @@ export const useSharedAPIReport = ({
const error = keys.reduce(
(acc, key, i) => {
- acc[key] = queries[i].error as unknown as string
+ acc[key] = queries[i].error
return acc
},
- {} as { [K in keyof typeof SHARED_API_REPORT_SQL]: string }
+ {} as { [K in keyof typeof SHARED_API_REPORT_SQL]: Error | null }
)
const isLoading = keys.reduce(
(acc, key, i) => {
- acc[key] = queries[i].isLoading
+ acc[key] = !isQueryModeReady || queries[i].isLoading
return acc
},
{} as { [K in keyof typeof SHARED_API_REPORT_SQL]: boolean }
@@ -333,38 +358,13 @@ export const useSharedAPIReport = ({
const isLoadingData = Object.values(isLoading).some(Boolean)
- const SQLMap: Record<SharedAPIReportKey, SafeLogSqlFragment> = {
- totalRequests: SHARED_API_REPORT_SQL.totalRequests.safeSql(
- allFilters,
- filterByMapSource[filterBy]
- ),
- topRoutes: SHARED_API_REPORT_SQL.topRoutes.safeSql(allFilters, filterByMapSource[filterBy]),
- errorCounts: SHARED_API_REPORT_SQL.errorCounts.safeSql(allFilters, filterByMapSource[filterBy]),
- topErrorRoutes: SHARED_API_REPORT_SQL.topErrorRoutes.safeSql(
- allFilters,
- filterByMapSource[filterBy]
- ),
- responseSpeed: SHARED_API_REPORT_SQL.responseSpeed.safeSql(
- allFilters,
- filterByMapSource[filterBy]
- ),
- topSlowRoutes: SHARED_API_REPORT_SQL.topSlowRoutes.safeSql(
- allFilters,
- filterByMapSource[filterBy]
- ),
- networkTraffic: SHARED_API_REPORT_SQL.networkTraffic.safeSql(
- allFilters,
- filterByMapSource[filterBy]
- ),
- }
-
return {
data,
error,
isLoading,
isLoadingData,
- isRefetching: queryClient.isFetching({ queryKey: DEFAULT_KEYS }) > 0 || false,
- refetch: () => queryClient.invalidateQueries({ queryKey: DEFAULT_KEYS }),
+ isRefetching: queryClient.isFetching({ queryKey: reportKeys.allSharedApi }) > 0 || false,
+ refetch: () => queryClient.invalidateQueries({ queryKey: reportKeys.allSharedApi }),
filters,
addFilter,
removeFilters,
diff --git a/apps/studio/data/reports/api-report-query.ts b/apps/studio/data/reports/api-report-query.ts
index 56e8c018590..03cc9e71fc4 100644
--- a/apps/studio/data/reports/api-report-query.ts
+++ b/apps/studio/data/reports/api-report-query.ts
@@ -1,33 +1,128 @@
-import { useParams } from 'common'
-import { isEqual } from 'lodash'
-import { useEffect, useState } from 'react'
+import { useQueries } from '@tanstack/react-query'
+import { FeatureFlagContext, useFlag, useParams } from 'common'
+import isEqual from 'lodash/isEqual'
+import { useContext, useState } from 'react'
import { PRESET_CONFIG } from '@/components/interfaces/Reports/Reports.constants'
-import { ReportFilterItem } from '@/components/interfaces/Reports/Reports.types'
-import { getLogsSql, queriesFactory } from '@/components/interfaces/Reports/Reports.utils'
-import type { LogsEndpointParams } from '@/components/interfaces/Settings/Logs/Logs.types'
+import type { ReportFilterItem } from '@/components/interfaces/Reports/Reports.types'
+import { getLogsSql } from '@/components/interfaces/Reports/Reports.utils'
+import {
+ EXPLORER_DATEPICKER_HELPERS,
+ getDefaultHelper,
+} from '@/components/interfaces/Settings/Logs/Logs.constants'
+import type { LogData, LogsEndpointParams } from '@/components/interfaces/Settings/Logs/Logs.types'
+import { executeAnalyticsSql } from '@/data/logs/execute-analytics-sql'
+import { logsAllEndpointUrl } from '@/data/logs/logs-endpoint'
+import type { SafeLogSqlFragment } from '@/data/logs/safe-analytics-sql'
+import { reportKeys, type ApiReportRequestParams } from '@/data/reports/keys'
+import { IS_PLATFORM } from '@/lib/constants'
import { useDatabaseSelectorStateSnapshot } from '@/state/database-selector'
+const apiQueryNames = [
+ 'totalRequests',
+ 'topRoutes',
+ 'errorCounts',
+ 'topErrorRoutes',
+ 'responseSpeed',
+ 'topSlowRoutes',
+ 'networkTraffic',
+ 'requestsByCountry',
+] as const
+
+const fetchApiReportMetric = async ({
+ projectRef,
+ params,
+ sql,
+ useOtel,
+ signal,
+}: {
+ projectRef: string | undefined
+ params: ApiReportRequestParams
+ sql: SafeLogSqlFragment
+ useOtel: boolean
+ signal: AbortSignal
+}): Promise<LogData[]> => {
+ if (projectRef === undefined) throw new Error('projectRef is required')
+
+ const data = await executeAnalyticsSql({
+ projectRef,
+ endpoint: logsAllEndpointUrl(useOtel),
+ sql,
+ iso_timestamp_start: params.iso_timestamp_start,
+ iso_timestamp_end: params.iso_timestamp_end,
+ method: 'get',
+ signal,
+ })
+
+ if (data?.error !== undefined) {
+ const message = typeof data.error === 'string' ? data.error : data.error.message
+ throw new Error(message)
+ }
+ return (data?.result ?? []) as LogData[]
+}
+
export const useApiReport = () => {
const { ref: projectRef } = useParams()
const state = useDatabaseSelectorStateSnapshot()
+ const flagUseOtel = useFlag('otelReports')
+ const { hasLoaded: hasLoadedFlags } = useContext(FeatureFlagContext)
+ const [filters, setFilters] = useState<ReportFilterItem[]>([])
+ const [requestParams, setRequestParams] = useState<ApiReportRequestParams>(() => {
+ const defaultDateRange = getDefaultHelper(EXPLORER_DATEPICKER_HELPERS)
+ return {
+ iso_timestamp_start: defaultDateRange.calcFrom(),
+ iso_timestamp_end: defaultDateRange.calcTo(),
+ }
+ })
const identifier = state.selectedDatabaseId
- const [filters, setFilters] = useState<ReportFilterItem[]>([])
+ const useOtel = IS_PLATFORM && Boolean(flagUseOtel)
+ const resolvedProjectRef = IS_PLATFORM ? projectRef : (projectRef ?? 'default')
+ const areQueriesReady =
+ (!IS_PLATFORM || hasLoadedFlags === true) && resolvedProjectRef !== undefined
+ const formattedFilters: ReportFilterItem[] = [
+ ...filters,
+ ...(identifier !== undefined
+ ? [{ key: 'identifier', value: identifier, compare: 'is' } as ReportFilterItem]
+ : []),
+ ]
+ const sql = {
+ totalRequests: getLogsSql(PRESET_CONFIG.api.queries.totalRequests, formattedFilters, useOtel),
+ topRoutes: getLogsSql(PRESET_CONFIG.api.queries.topRoutes, formattedFilters, useOtel),
+ errorCounts: getLogsSql(PRESET_CONFIG.api.queries.errorCounts, formattedFilters, useOtel),
+ topErrorRoutes: getLogsSql(PRESET_CONFIG.api.queries.topErrorRoutes, formattedFilters, useOtel),
+ responseSpeed: getLogsSql(PRESET_CONFIG.api.queries.responseSpeed, formattedFilters, useOtel),
+ topSlowRoutes: getLogsSql(PRESET_CONFIG.api.queries.topSlowRoutes, formattedFilters, useOtel),
+ networkTraffic: getLogsSql(PRESET_CONFIG.api.queries.networkTraffic, formattedFilters, useOtel),
+ requestsByCountry: getLogsSql(
+ PRESET_CONFIG.api.queries.requestsByCountry,
+ formattedFilters,
+ useOtel
+ ),
+ }
- const queryHooks = queriesFactory<keyof typeof PRESET_CONFIG.api.queries>(
- PRESET_CONFIG.api.queries,
- projectRef ?? 'default'
- )
- const totalRequests = queryHooks.totalRequests()
- const topRoutes = queryHooks.topRoutes()
- const errorCounts = queryHooks.errorCounts()
- const topErrorRoutes = queryHooks.topErrorRoutes()
- const responseSpeed = queryHooks.responseSpeed()
- const topSlowRoutes = queryHooks.topSlowRoutes()
- const networkTraffic = queryHooks.networkTraffic()
- const requestsByCountry = queryHooks.requestsByCountry()
- const activeHooks = [
+ const activeQueries = useQueries({
+ queries: apiQueryNames.map((queryName) => ({
+ queryKey: reportKeys.apiMetric(
+ resolvedProjectRef,
+ queryName,
+ requestParams,
+ sql[queryName],
+ useOtel
+ ),
+ queryFn: ({ signal }: { signal: AbortSignal }) =>
+ fetchApiReportMetric({
+ projectRef: resolvedProjectRef,
+ params: requestParams,
+ sql: sql[queryName],
+ useOtel,
+ signal,
+ }),
+ enabled: areQueriesReady,
+ refetchOnWindowFocus: false,
+ })),
+ })
+ const [
totalRequests,
topRoutes,
errorCounts,
@@ -36,125 +131,66 @@ export const useApiReport = () => {
topSlowRoutes,
networkTraffic,
requestsByCountry,
- ]
+ ] = activeQueries
const addFilter = (filter: ReportFilterItem) => {
- // use a deep equal when comparing objects.
- if (filters.some((f) => isEqual(f, filter))) return
- setFilters((prev) =>
- [...prev, filter].sort((a, b) => {
- const keyA = a.key.toLowerCase()
- const keyB = b.key.toLowerCase()
- if (keyA < keyB) {
- return -1
- }
- if (keyA > keyB) {
- return 1
- }
- return 0
- })
+ if (filters.some((item) => isEqual(item, filter))) return
+ setFilters((previousFilters) =>
+ [...previousFilters, filter].sort((first, second) =>
+ first.key.toLowerCase().localeCompare(second.key.toLowerCase())
+ )
)
}
const removeFilter = (filter: ReportFilterItem) => removeFilters([filter])
- const removeFilters = (toRemove: ReportFilterItem[]) => {
- setFilters((prev) => {
- return prev.filter((f) => !toRemove.find((r) => isEqual(f, r)))
- })
+ const removeFilters = (filtersToRemove: ReportFilterItem[]) => {
+ setFilters((previousFilters) =>
+ previousFilters.filter((filter) => !filtersToRemove.some((item) => isEqual(filter, item)))
+ )
}
-
- // [Joshen] Keeping database selector separate from filter state, and merging them here for simplicity
- const formattedFilters: ReportFilterItem[] = [
- ...filters,
- ...(identifier !== undefined
- ? [{ key: 'identifier', value: identifier, compare: 'is' } as ReportFilterItem]
- : []),
- ]
-
- useEffect(() => {
- // update sql for each query
- if (totalRequests.changeQuery) {
- totalRequests.changeQuery(
- getLogsSql(PRESET_CONFIG.api.queries.totalRequests, formattedFilters)
- )
- }
- if (topRoutes.changeQuery) {
- topRoutes.changeQuery(getLogsSql(PRESET_CONFIG.api.queries.topRoutes, formattedFilters))
- }
- if (errorCounts.changeQuery) {
- errorCounts.changeQuery(getLogsSql(PRESET_CONFIG.api.queries.errorCounts, formattedFilters))
- }
-
- if (topErrorRoutes.changeQuery) {
- topErrorRoutes.changeQuery(
- getLogsSql(PRESET_CONFIG.api.queries.topErrorRoutes, formattedFilters)
- )
- }
- if (responseSpeed.changeQuery) {
- responseSpeed.changeQuery(
- getLogsSql(PRESET_CONFIG.api.queries.responseSpeed, formattedFilters)
- )
- }
-
- if (topSlowRoutes.changeQuery) {
- topSlowRoutes.changeQuery(
- getLogsSql(PRESET_CONFIG.api.queries.topSlowRoutes, formattedFilters)
- )
- }
-
- if (networkTraffic.changeQuery) {
- networkTraffic.changeQuery(
- getLogsSql(PRESET_CONFIG.api.queries.networkTraffic, formattedFilters)
- )
- }
- if (requestsByCountry.changeQuery) {
- requestsByCountry.changeQuery(
- getLogsSql(PRESET_CONFIG.api.queries.requestsByCountry, formattedFilters)
- )
- }
- }, [JSON.stringify(formattedFilters)])
-
const handleRefresh = async () => {
- activeHooks.forEach((hook) => hook.runQuery())
+ if (!areQueriesReady) return
+ await Promise.all(activeQueries.map((query) => query.refetch()))
}
-
const handleSetParams = (params: Partial<LogsEndpointParams>) => {
- activeHooks.forEach((hook) => {
- hook.setParams?.((prev: LogsEndpointParams) => ({ ...prev, ...params }))
- })
+ setRequestParams((previousParams) => ({
+ iso_timestamp_start: params.iso_timestamp_start ?? previousParams.iso_timestamp_start,
+ iso_timestamp_end: params.iso_timestamp_end ?? previousParams.iso_timestamp_end,
+ }))
}
- const isLoading = activeHooks.some((hook) => hook.isLoading)
+ const isLoading =
+ !areQueriesReady || activeQueries.some((query) => query.isPending || query.isRefetching)
return {
data: {
- totalRequests: totalRequests.logData,
- errorCounts: errorCounts.logData,
- responseSpeed: responseSpeed.logData,
- topRoutes: topRoutes.logData,
- topErrorRoutes: topErrorRoutes.logData,
- topSlowRoutes: topSlowRoutes.logData,
- networkTraffic: networkTraffic.logData,
- requestsByCountry: requestsByCountry.logData,
+ totalRequests: totalRequests.data ?? [],
+ errorCounts: errorCounts.data ?? [],
+ responseSpeed: responseSpeed.data ?? [],
+ topRoutes: topRoutes.data ?? [],
+ topErrorRoutes: topErrorRoutes.data ?? [],
+ topSlowRoutes: topSlowRoutes.data ?? [],
+ networkTraffic: networkTraffic.data ?? [],
+ requestsByCountry: requestsByCountry.data ?? [],
},
params: {
- totalRequests: totalRequests.params,
- errorCounts: errorCounts.params,
- responseSpeed: responseSpeed.params,
- topRoutes: topRoutes.params,
- topErrorRoutes: topErrorRoutes.params,
- topSlowRoutes: topSlowRoutes.params,
- networkTraffic: networkTraffic.params,
- requestsByCountry: requestsByCountry.params,
+ totalRequests: { ...requestParams, sql: sql.totalRequests },
+ errorCounts: { ...requestParams, sql: sql.errorCounts },
+ responseSpeed: { ...requestParams, sql: sql.responseSpeed },
+ topRoutes: { ...requestParams, sql: sql.topRoutes },
+ topErrorRoutes: { ...requestParams, sql: sql.topErrorRoutes },
+ topSlowRoutes: { ...requestParams, sql: sql.topSlowRoutes },
+ networkTraffic: { ...requestParams, sql: sql.networkTraffic },
+ requestsByCountry: { ...requestParams, sql: sql.requestsByCountry },
},
error: {
- totalRequest: totalRequests.error,
- errorCounts: errorCounts.error,
- responseSpeed: responseSpeed.error,
- topRoutes: topRoutes.error,
- topErrorRoute: topErrorRoutes.error,
- topSlowRoutes: topSlowRoutes.error,
- networkTraffic: networkTraffic.error,
- requestsByCountry: requestsByCountry.error,
+ totalRequest: totalRequests.error?.message ?? null,
+ errorCounts: errorCounts.error?.message ?? null,
+ responseSpeed: responseSpeed.error?.message ?? null,
+ topRoutes: topRoutes.error?.message ?? null,
+ topErrorRoute: topErrorRoutes.error?.message ?? null,
+ topSlowRoutes: topSlowRoutes.error?.message ?? null,
+ networkTraffic: networkTraffic.error?.message ?? null,
+ requestsByCountry: requestsByCountry.error?.message ?? null,
},
mergeParams: handleSetParams,
filters,
diff --git a/apps/studio/data/reports/keys.ts b/apps/studio/data/reports/keys.ts
new file mode 100644
index 00000000000..308d0d2ea87
--- /dev/null
+++ b/apps/studio/data/reports/keys.ts
@@ -0,0 +1,57 @@
+import type { LogsEndpointParams } from '@/components/interfaces/Settings/Logs/Logs.types'
+import type { SafeLogSqlFragment } from '@/data/logs/safe-analytics-sql'
+
+export type ApiReportRequestParams = Required<
+ Pick<LogsEndpointParams, 'iso_timestamp_start' | 'iso_timestamp_end'>
+>
+
+type SharedApiReportMetricParams<
+ FilterBy extends string,
+ QueryName extends string,
+ Filters extends readonly unknown[],
+> = {
+ filterBy: FilterBy
+ queryName: QueryName
+ source: string
+ filters: Filters
+ start: string
+ end: string
+ projectRef: string
+ useOtel: boolean
+}
+
+export const reportKeys = {
+ apiMetric: (
+ projectRef: string | undefined,
+ queryName: string,
+ params: ApiReportRequestParams,
+ sql: SafeLogSqlFragment,
+ useOtel: boolean
+ ) => ['projects', projectRef, 'api-report', queryName, params, sql, { otel: useOtel }] as const,
+ allSharedApi: ['shared-api-report'] as const,
+ sharedApiMetric: <
+ FilterBy extends string,
+ QueryName extends string,
+ Filters extends readonly unknown[],
+ >({
+ filterBy,
+ queryName,
+ source,
+ filters,
+ start,
+ end,
+ projectRef,
+ useOtel,
+ }: SharedApiReportMetricParams<FilterBy, QueryName, Filters>) =>
+ [
+ ...reportKeys.allSharedApi,
+ filterBy,
+ queryName,
+ source,
+ filters,
+ start,
+ end,
+ projectRef,
+ { otel: useOtel },
+ ] as const,
+}