Skip to content

The easy-to-use open source Business Intelligence and Embedded Analytics tool that lets everyone work with data :bar_chart:

Add Data Apps page to Monitor (#84844)

Timofey Kachalovce470bc951ee
diff --git a/e2e/test/scenarios/monitor/ai-auditing/data-apps-analytics.cy.spec.ts b/e2e/test/scenarios/monitor/ai-auditing/data-apps-analytics.cy.spec.ts
new file mode 100644
index 00000000000..e4a99e598d3
--- /dev/null
+++ b/e2e/test/scenarios/monitor/ai-auditing/data-apps-analytics.cy.spec.ts
@@ -0,0 +1,223 @@
+import { USERS, WRITABLE_DB_ID } from "e2e/support/cypress_data";
+import { SAMPLE_DATABASE } from "e2e/support/cypress_sample_database";
+import type { PortableTable } from "e2e/support/helpers";
+
+const { H } = cy;
+const { ORDERS_ID } = SAMPLE_DATABASE;
+
+const DATA_APPS_ANALYTICS_PATH = "/monitor/ai-auditing/data-apps";
+
+const SCOREBOARD_TABLE = "scoreboard_actions";
+const ORDERS_TABLE: PortableTable = ["Sample Database", "PUBLIC", "ORDERS"];
+
+const appRoot = (slug: string) =>
+ `${Cypress.config("projectRoot")}/e2e/support/assets/data-apps/${slug}`;
+
+/** Reads a saved question when it opens. */
+const QUESTION_APP = {
+ slug: "synced-app",
+ displayName: "Synced App",
+ collection: "syncedAppCollection01",
+ question: "syncedAppOrdersCount1",
+};
+
+/** Runs an action on a click. */
+const ACTIONS_APP = {
+ slug: "synced-actions-app",
+ displayName: "Synced Actions App",
+ collection: "syncedActionsAppColl1",
+};
+
+const ADMIN_NAME = `${USERS.admin.first_name} ${USERS.admin.last_name}`;
+
+function removeTestFiles() {
+ cy.task("removeDataAppPaths", {
+ paths: [
+ `${appRoot(QUESTION_APP.slug)}/queries`,
+ `${appRoot(QUESTION_APP.slug)}/collections`,
+ `${appRoot(ACTIONS_APP.slug)}/actions`,
+ `${appRoot(ACTIONS_APP.slug)}/collections`,
+ ],
+ });
+}
+
+function writeQuestionAppResources(root: string) {
+ return H.writeDataAppResources(root, {
+ collection: H.dataAppRepresentations.collection(
+ QUESTION_APP.collection,
+ `Data App: ${QUESTION_APP.displayName}`,
+ ),
+ cards: [
+ H.dataAppRepresentations.card({
+ entityId: QUESTION_APP.question,
+ name: "OrdersCount",
+ type: "question",
+ collection: QUESTION_APP.collection,
+ table: ORDERS_TABLE,
+ }),
+ ],
+ });
+}
+
+function publishQuestionApp() {
+ const root = appRoot(QUESTION_APP.slug);
+
+ H.declareDataAppQueries(root, [
+ {
+ name: "OrdersCount",
+ tableId: ORDERS_ID,
+ savedQuestionEntityId: QUESTION_APP.question,
+ },
+ ]);
+ writeQuestionAppResources(root);
+ return H.publishDataApp(root, QUESTION_APP.slug);
+}
+
+// A publish makes the repository's collections what the app's root holds, so this root carries the
+// question app's collection too; otherwise the pull would remove its saved question.
+function publishActionsApp() {
+ const root = appRoot(ACTIONS_APP.slug);
+
+ return H.createDataAppScoreboardAction().then((source) => {
+ const actionCopy = H.newEntityId();
+
+ H.declareDataAppActions(root, [
+ {
+ exportName: "CreateScore",
+ sourceActionId: source.id,
+ copiedActionEntityId: actionCopy,
+ },
+ ]);
+
+ return H.serializeDataAppActionCopies(
+ [{ sourceActionId: source.id, entityId: actionCopy }],
+ ACTIONS_APP.collection,
+ )
+ .then((actions) =>
+ H.writeDataAppResources(root, {
+ collection: H.dataAppRepresentations.collection(
+ ACTIONS_APP.collection,
+ `Data App: ${ACTIONS_APP.displayName}`,
+ ),
+ actions,
+ }),
+ )
+ .then(() => writeQuestionAppResources(root))
+ .then(() =>
+ H.publishDataApp(root, ACTIONS_APP.slug, { initializeRepo: false }),
+ );
+ });
+}
+
+// The first query against the audit view can take a while to settle, and the page's other
+// queries share `/api/dataset`, so this waits for the table to stop loading rather than on an alias.
+function logTable() {
+ cy.findByTestId("data-app-log-table", { timeout: 20000 }).should(
+ "have.attr",
+ "aria-busy",
+ "false",
+ );
+ return cy.findByTestId("data-app-log-table");
+}
+
+const logRows = () => logTable().findAllByTestId("data-app-log-row");
+
+function selectFilterOption(label: string, option: string) {
+ H.main().findByLabelText(label).click();
+ H.popover().findByRole("option", { name: option }).click();
+}
+
+// The log has more columns than the default viewport fits.
+describe(
+ "scenarios > monitor > ai auditing > data app analytics",
+ { tags: ["@external", "@actions"], viewportWidth: 1600 },
+ () => {
+ beforeEach(() => {
+ H.restore("postgres-writable");
+ cy.signInAsAdmin();
+ H.activateToken("bleeding-edge");
+
+ H.resetTestTable({ type: "postgres", table: SCOREBOARD_TABLE });
+ H.resyncDatabase({ dbId: WRITABLE_DB_ID, tableName: SCOREBOARD_TABLE });
+ H.setActionsEnabledForDB(WRITABLE_DB_ID);
+
+ removeTestFiles();
+ });
+
+ after(() => {
+ removeTestFiles();
+ });
+
+ it("lists the questions and actions published data apps run, and narrows the log by entity type and app", () => {
+ publishQuestionApp();
+ publishActionsApp();
+
+ cy.log("Read the question in one app");
+ cy.intercept("POST", "/api/dataset").as("appQuery");
+ H.mockDataApp(QUESTION_APP.slug, {
+ displayName: QUESTION_APP.displayName,
+ });
+ cy.visit(`/apps/${QUESTION_APP.slug}`);
+ H.dataAppIframe(QUESTION_APP.displayName)
+ .findByTestId("synced-app-total", { timeout: 30000 })
+ .should(($total) => {
+ expect(Number($total.text())).to.be.greaterThan(0);
+ });
+ cy.wait("@appQuery");
+
+ cy.log("Run the action in the other");
+ cy.intercept("POST", "/api/action/*/execute").as("execute");
+ H.mockDataApp(ACTIONS_APP.slug, {
+ displayName: ACTIONS_APP.displayName,
+ });
+ cy.visit(`/apps/${ACTIONS_APP.slug}`);
+ H.dataAppIframe(ACTIONS_APP.displayName).within(() => {
+ cy.findByTestId("action-execute", { timeout: 30000 }).click();
+ cy.findByTestId("action-output").should("have.text", "executed");
+ });
+ cy.wait("@execute");
+
+ cy.log(
+ "The page names the apps from the installed list, which the app mocks replaced",
+ );
+ cy.intercept("GET", "/api/apps", (req) => {
+ req.continue();
+ });
+
+ cy.visit(DATA_APPS_ANALYTICS_PATH);
+ cy.findByTestId("monitor-nav")
+ .findByRole("link", { name: "Data app analytics" })
+ .should("be.visible");
+ H.main()
+ .findByRole("heading", { name: "Data app analytics" })
+ .should("be.visible");
+
+ cy.log("Both apps' records, by app and user");
+ logRows()
+ .should("contain", QUESTION_APP.displayName)
+ .and("contain", QUESTION_APP.slug)
+ .and("contain", ACTIONS_APP.displayName)
+ .and("contain", ACTIONS_APP.slug)
+ .and("contain", "Question")
+ .and("contain", "OrdersCount")
+ .and("contain", ADMIN_NAME);
+
+ cy.log("Only the action runs");
+ selectFilterOption("Entity type", "Action");
+ cy.location("search").should("contain", "type=action");
+ logRows()
+ .should("contain", ACTIONS_APP.slug)
+ .and("not.contain", QUESTION_APP.slug)
+ .and("not.contain", "Question");
+
+ cy.log("Only the question app's records");
+ selectFilterOption("Entity type", "All entity types");
+ selectFilterOption("Data app", QUESTION_APP.displayName);
+ cy.location("search").should("contain", `app=${QUESTION_APP.slug}`);
+ logRows()
+ .should("contain", QUESTION_APP.slug)
+ .and("contain", "Question")
+ .and("not.contain", ACTIONS_APP.slug);
+ });
+ },
+);
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/cli-analytics/components/CliAnalyticsSectionLayout.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/cli-analytics/components/CliAnalyticsSectionLayout.tsx
index b8174b0f61a..f8bb715ac15 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/cli-analytics/components/CliAnalyticsSectionLayout.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/cli-analytics/components/CliAnalyticsSectionLayout.tsx
@@ -135,17 +135,26 @@ export function CliAnalyticsSectionLayout() {
<CliCallsFilter
date={date}
onDateChange={(val) => patchUrlState({ date: val, page: 0 })}
- user={user}
- onUserChange={(val) => patchUrlState({ user: val, page: 0 })}
- userOptions={userOptions}
- group={group}
- onGroupChange={(val) => patchUrlState({ group: val, page: 0 })}
- groupOptions={groupOptions}
- groupNoFilterValue={groupNoFilterValue}
- tenant={tenant}
- onTenantChange={(val) => patchUrlState({ tenant: val, page: 0 })}
- tenantOptions={tenantOptions}
- hasTenants={hasTenants}
+ userFilter={{
+ value: user,
+ options: userOptions,
+ onChange: (val) => patchUrlState({ user: val, page: 0 }),
+ }}
+ groupFilter={{
+ value: group,
+ options: groupOptions,
+ noFilterValue: groupNoFilterValue,
+ onChange: (val) => patchUrlState({ group: val, page: 0 }),
+ }}
+ tenantFilter={
+ hasTenants
+ ? {
+ value: tenant,
+ options: tenantOptions,
+ onChange: (val) => patchUrlState({ tenant: val, page: 0 }),
+ }
+ : undefined
+ }
/>
}
emptyState={
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/cli-analytics/query-utils.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/cli-analytics/query-utils.ts
index 57dc075f944..b2583b5b2b2 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/cli-analytics/query-utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/cli-analytics/query-utils.ts
@@ -5,7 +5,7 @@ import {
breakoutByColumn,
findColumn,
joinGroupMembers,
-} from "metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils";
+} from "metabase-enterprise/monitor/query-utils";
import type {
CardMetadata,
ColumnMetadata,
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/components/AiAnalyticsSectionLayout/AiAnalyticsSectionLayout.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/components/AiAnalyticsSectionLayout/AiAnalyticsSectionLayout.tsx
index 1166c219aff..cecc54c9976 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/components/AiAnalyticsSectionLayout/AiAnalyticsSectionLayout.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/components/AiAnalyticsSectionLayout/AiAnalyticsSectionLayout.tsx
@@ -17,7 +17,7 @@ type AiAnalyticsSectionLayoutProps = {
isInitialLoading: boolean;
isTableRoute: boolean;
showEmpty: boolean;
- tabs: PillTab[];
+ tabs?: PillTab[];
filtersAction?: ReactNode;
title: string;
};
@@ -36,7 +36,7 @@ export function AiAnalyticsSectionLayout({
}: AiAnalyticsSectionLayoutProps) {
const sectionContent = (
<>
- <PillTabNavigation tabs={tabs} />
+ {tabs && <PillTabNavigation tabs={tabs} />}
<Flex justify="space-between" align="center" gap="md">
{filters}
{filtersAction}
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/components/NewQuestionButton/NewQuestionButton.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/components/NewQuestionButton/NewQuestionButton.tsx
index 1ceba9297c7..c702c97d0c2 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/components/NewQuestionButton/NewQuestionButton.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/components/NewQuestionButton/NewQuestionButton.tsx
@@ -9,9 +9,14 @@ import * as Lib from "metabase-lib";
type NewQuestionButtonProps = {
viewName: string;
+ /** Narrows the view to the rows the page shows, for a view other pages share. */
+ scopeQuery?: (query: Lib.Query) => Lib.Query;
};
-export function NewQuestionButton({ viewName }: NewQuestionButtonProps) {
+export function NewQuestionButton({
+ viewName,
+ scopeQuery,
+}: NewQuestionButtonProps) {
const { provider, table } = useAuditTable(viewName);
const url = useMemo(() => {
@@ -20,10 +25,10 @@ export function NewQuestionButton({ viewName }: NewQuestionButtonProps) {
}
const query = Lib.queryFromTableOrCardMetadata(provider, table);
return Urls.newQuestion({
- dataset_query: Lib.toJsQuery(query),
+ dataset_query: Lib.toJsQuery(scopeQuery ? scopeQuery(query) : query),
mode: "notebook",
});
- }, [provider, table]);
+ }, [provider, scopeQuery, table]);
if (url == null) {
return null;
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppFilterSelect.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppFilterSelect.tsx
new file mode 100644
index 00000000000..d5ccd0ac85f
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppFilterSelect.tsx
@@ -0,0 +1,94 @@
+import { useMemo } from "react";
+import { t } from "ttag";
+
+import { skipToken, useGetAdhocQueryQuery } from "metabase/api";
+import { FILTER_WIDTH } from "metabase/monitor/constants";
+import type { DateFilterValue } from "metabase/querying/common/types";
+import { Select } from "metabase/ui";
+import { useListDataAppsQuery } from "metabase-enterprise/api";
+import { buildLoggedDataAppsQuery } from "metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils";
+import * as Lib from "metabase-lib";
+import type { DataApp, RowValue } from "metabase-types/api";
+
+const ALL_DATA_APPS = "";
+
+// A selected app that isn't installed is listed under "Removed" even when the log doesn't name it, so the
+// select never shows blank.
+function getDataAppOptions(
+ dataApps: readonly DataApp[],
+ loggedNames: readonly RowValue[],
+ selectedName: string | null,
+) {
+ const installed = dataApps.map((dataApp) => ({
+ value: dataApp.name,
+ label: dataApp.display_name,
+ }));
+ const installedNames = new Set(installed.map((option) => option.value));
+ const removedNames = new Set(
+ [...loggedNames, selectedName].filter(
+ (name): name is string =>
+ typeof name === "string" && !installedNames.has(name),
+ ),
+ );
+ const removed = [...removedNames]
+ .sort()
+ .map((name) => ({ value: name, label: name }));
+ return [
+ // A group without a name renders no heading, so "All data apps" stands on its own.
+ { group: "", items: [{ value: ALL_DATA_APPS, label: t`All data apps` }] },
+ { group: t`Installed`, items: installed },
+ { group: t`Removed`, items: removed },
+ ].filter((group) => group.items.length > 0);
+}
+
+type DataAppFilterSelectProps = {
+ value: string | null;
+ onChange: (value: string | null) => void;
+ provider: Lib.MetadataProvider | null;
+ table: Lib.TableMetadata | Lib.CardMetadata | null;
+ dateFilter: DateFilterValue;
+};
+
+export function DataAppFilterSelect({
+ value,
+ onChange,
+ provider,
+ table,
+ dateFilter,
+}: DataAppFilterSelectProps) {
+ const { data: dataApps } = useListDataAppsQuery();
+
+ const loggedDataAppsQuery = useMemo(
+ () =>
+ provider && table
+ ? Lib.toJsQuery(
+ buildLoggedDataAppsQuery({ provider, table, dateFilter }),
+ )
+ : skipToken,
+ [provider, table, dateFilter],
+ );
+ const { data: loggedDataApps } = useGetAdhocQueryQuery(loggedDataAppsQuery);
+
+ const options = useMemo(
+ () =>
+ getDataAppOptions(
+ dataApps ?? [],
+ (loggedDataApps?.data?.rows ?? []).map(([name]) => name),
+ value,
+ ),
+ [dataApps, loggedDataApps, value],
+ );
+
+ return (
+ <Select
+ data={options}
+ value={value ?? ALL_DATA_APPS}
+ onChange={(val) => onChange(val === ALL_DATA_APPS ? null : val)}
+ aria-label={t`Data app`}
+ searchable
+ w={FILTER_WIDTH}
+ bdrs="xs"
+ data-testid="data-app-filter-select"
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppLogTable.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppLogTable.tsx
new file mode 100644
index 00000000000..627714c757f
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppLogTable.tsx
@@ -0,0 +1,353 @@
+import { type ReactNode, useMemo } from "react";
+import { t } from "ttag";
+
+import { useGetAdhocQueryQuery } from "metabase/api";
+import { DateTime } from "metabase/common/components/DateTime";
+import { LoadingAndErrorWrapper } from "metabase/common/components/LoadingAndErrorWrapper";
+import { PaginationControls } from "metabase/common/components/PaginationControls";
+import { useScrollToTop, useSortingStateChange } from "metabase/common/hooks";
+import { MonitorEmptyState } from "metabase/monitor/components/MonitorEmptyState";
+import { MonitorTableCard } from "metabase/monitor/components/MonitorTableCard";
+import { PAGE_SIZE } from "metabase/monitor/constants";
+import {
+ Box,
+ Ellipsified,
+ Flex,
+ LoadingOverlay,
+ Stack,
+ TreeTable,
+ type TreeTableColumnDef,
+ type TreeTableInstance,
+ TreeTableSkeleton,
+ useTreeTableInstance,
+} from "metabase/ui";
+import { EMPTY_CELL_PLACEHOLDER } from "metabase/utils/constants";
+import { formatNumber } from "metabase/utils/formatting";
+import { useListDataAppsQuery } from "metabase-enterprise/api";
+import {
+ DATA_APP_LOG_COLUMNS,
+ DEFAULT_SORTING,
+ type DataAppLogColumn,
+ type DataAppLogFilters,
+ buildDataAppLogRowsQuery,
+ dataAppLogColumnKeys,
+} from "metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils";
+import * as Lib from "metabase-lib";
+import type { RowValue, SortingOptions } from "metabase-types/api";
+
+import { getEntityTypeLabel } from "./EntityTypeFilterSelect";
+import { type LogRow, getEffectiveSorting, getLogRows } from "./utils";
+
+/** Installed data apps' display names, by slug. */
+type DataAppNames = ReadonlyMap<string, string>;
+
+type LogColumn = {
+ id: string;
+ key: DataAppLogColumn;
+ title: string;
+ /** Defaults to sortable. */
+ isSortable?: boolean;
+ align?: "right";
+ grow?: boolean;
+ render?: (value: RowValue, dataAppNames: DataAppNames) => ReactNode;
+};
+
+const isBlank = (value: RowValue) => value === null || value === "";
+
+const renderDateTime = (value: RowValue) =>
+ value === null ? EMPTY_CELL_PLACEHOLDER : <DateTime value={String(value)} />;
+
+const renderNumber = (value: RowValue) =>
+ value === null ? EMPTY_CELL_PLACEHOLDER : formatNumber(Number(value));
+
+const renderLongText = (value: RowValue) =>
+ isBlank(value) ? (
+ EMPTY_CELL_PLACEHOLDER
+ ) : (
+ <Ellipsified>{String(value)}</Ellipsified>
+ );
+
+// These ids come back remapped to a name, which is what the cell shows. Sorting would still
+// order by the id, so it's off.
+const getNamedReferenceMeta = (title: string) => ({ title, isSortable: false });
+
+const COLUMN_META: Record<
+ DataAppLogColumn,
+ () => Omit<LogColumn, "id" | "key">
+> = {
+ started_at: () => ({ title: t`Started at`, render: renderDateTime }),
+ running_time_seconds: () => ({
+ title: t`Running time (s)`,
+ align: "right",
+ render: renderNumber,
+ }),
+ result_rows: () => ({
+ title: t`Result rows`,
+ align: "right",
+ render: renderNumber,
+ }),
+ error: () => ({ title: t`Error`, grow: true, render: renderLongText }),
+ user_id: () => getNamedReferenceMeta(t`User`),
+ // Sorting would order by the action id, which groups the types only incidentally.
+ action_id: () => ({
+ title: t`Entity type`,
+ isSortable: false,
+ render: (value) =>
+ getEntityTypeLabel(value === null ? "question" : "action"),
+ }),
+ card_qualified_id: () => getNamedReferenceMeta(t`Question`),
+ database_qualified_id: () => getNamedReferenceMeta(t`Database`),
+ action_qualified_id: () => getNamedReferenceMeta(t`Action`),
+ query: () => ({ title: t`Query`, grow: true, render: renderLongText }),
+ embedding_client_identifier: () => ({ title: t`Identifier` }),
+ // eslint-disable-next-line metabase/no-literal-metabase-strings -- This string only shows for admins.
+ metabase_version: () => ({ title: t`Metabase version` }),
+ user_agent: () => ({ title: t`User agent`, render: renderLongText }),
+ sanitized_user_agent: () => ({ title: t`Sanitized user agent` }),
+ ip_address: () => ({ title: t`IP address` }),
+};
+
+const getDataAppNameColumn = (): LogColumn => ({
+ id: "data_app_name",
+ key: "embedding_client_identifier",
+ title: t`Name`,
+ // Sorting would order by the identifier, not the name shown.
+ isSortable: false,
+ render: (value, dataAppNames) =>
+ (value === null ? undefined : dataAppNames.get(String(value))) ??
+ EMPTY_CELL_PLACEHOLDER,
+});
+
+function getLogColumns(hasPii: boolean): LogColumn[] {
+ return dataAppLogColumnKeys(hasPii).flatMap((key) => {
+ const column = { id: key, key, ...COLUMN_META[key]() };
+ return key === "embedding_client_identifier"
+ ? [column, getDataAppNameColumn()]
+ : [column];
+ });
+}
+
+const isSortable = (column: LogColumn) => column.isSortable !== false;
+
+function renderCell(
+ column: LogColumn,
+ value: RowValue,
+ dataAppNames: DataAppNames,
+): ReactNode {
+ if (column.render) {
+ return column.render(value, dataAppNames);
+ }
+ return isBlank(value) ? EMPTY_CELL_PLACEHOLDER : String(value);
+}
+
+function useDataAppNames(): DataAppNames {
+ const { data: dataApps } = useListDataAppsQuery();
+
+ return useMemo(
+ () =>
+ new Map(
+ (dataApps ?? []).map((dataApp) => [dataApp.name, dataApp.display_name]),
+ ),
+ [dataApps],
+ );
+}
+
+type DataAppLogTableProps = {
+ provider: Lib.MetadataProvider | null;
+ table: Lib.TableMetadata | Lib.CardMetadata | null;
+ filters: DataAppLogFilters;
+ hasPii: boolean;
+ page: number;
+ total: number;
+ onPageChange: (page: number) => void;
+ sortingOptions: SortingOptions<DataAppLogColumn>;
+ onSortingOptionsChange: (
+ sortingOptions: SortingOptions<DataAppLogColumn>,
+ ) => void;
+};
+
+type DataAppLogTableInnerProps = DataAppLogTableProps & {
+ provider: Lib.MetadataProvider;
+ table: Lib.TableMetadata | Lib.CardMetadata;
+};
+
+export function DataAppLogTable({
+ provider,
+ table,
+ ...rest
+}: DataAppLogTableProps) {
+ if (!provider || !table) {
+ return null;
+ }
+ return <DataAppLogTableInner provider={provider} table={table} {...rest} />;
+}
+
+function DataAppLogTableInner({
+ provider,
+ table,
+ filters,
+ hasPii,
+ page,
+ total,
+ onPageChange,
+ sortingOptions,
+ onSortingOptionsChange,
+}: DataAppLogTableInnerProps) {
+ const dataAppNames = useDataAppNames();
+ const columns = useMemo(() => getLogColumns(hasPii), [hasPii]);
+
+ const effectiveSorting = useMemo(
+ () =>
+ getEffectiveSorting(
+ sortingOptions,
+ columns.filter(isSortable).map((column) => column.key),
+ ),
+ [columns, sortingOptions],
+ );
+
+ const jsQuery = useMemo(() => {
+ const query = buildDataAppLogRowsQuery({
+ provider,
+ table,
+ ...filters,
+ sorting: effectiveSorting,
+ hasPii,
+ });
+ return Lib.toJsQuery(
+ Lib.withPage(query, 0, { page: page + 1, items: PAGE_SIZE }),
+ );
+ }, [provider, table, filters, effectiveSorting, hasPii, page]);
+
+ const { data, isFetching, error } = useGetAdhocQueryQuery(jsQuery);
+
+ const rows = useMemo(
+ () =>
+ data?.data
+ ? getLogRows(
+ data.data,
+ columns.map((column) => column.key),
+ page,
+ )
+ : [],
+ [data, columns, page],
+ );
+
+ const treeColumns = useMemo<TreeTableColumnDef<LogRow>[]>(
+ () =>
+ columns.map((column) => ({
+ id: column.id,
+ header: column.title,
+ ...(column.grow
+ ? { minWidth: 120 }
+ : { width: "auto" as const, minWidth: 120, maxAutoWidth: 320 }),
+ enableSorting: isSortable(column),
+ sortDescFirst: column.key === DEFAULT_SORTING.sort_column,
+ accessorFn: (row) => row[column.key],
+ cell: ({ row }) => {
+ const value = row.original[column.key] ?? null;
+ const node = renderCell(column, value, dataAppNames);
+ return column.align === "right" ? (
+ <Box ta="right" w="100%">
+ {node}
+ </Box>
+ ) : (
+ node
+ );
+ },
+ })),
+ [columns, dataAppNames],
+ );
+
+ const { sortingState, onSortingChange } = useSortingStateChange({
+ sortingOptions: effectiveSorting,
+ columns: DATA_APP_LOG_COLUMNS,
+ defaultSorting: DEFAULT_SORTING,
+ onSortingOptionsChange,
+ });
+
+ const treeTableInstance = useTreeTableInstance<LogRow>({
+ data: rows,
+ columns: treeColumns,
+ sorting: sortingState,
+ manualSorting: true,
+ getNodeId: (row) => row.id,
+ onSortingChange,
+ });
+
+ useScrollToTop({
+ ref: treeTableInstance.containerRef,
+ keys: [page, effectiveSorting],
+ skip: isFetching,
+ });
+
+ const skeletonColumnWidths = columns.map(() => 1 / columns.length);
+
+ return (
+ <Stack gap="lg" flex={1} mih={0}>
+ <MonitorTableCard aria-busy={isFetching} data-testid="data-app-log-table">
+ <DataAppLogTableContent
+ error={error}
+ isLoaded={data !== undefined}
+ isFetching={isFetching}
+ instance={treeTableInstance}
+ skeletonColumnWidths={skeletonColumnWidths}
+ />
+ </MonitorTableCard>
+
+ {data && !error && (
+ <Flex justify="flex-end">
+ <PaginationControls
+ page={page}
+ pageSize={PAGE_SIZE}
+ itemsLength={rows.length}
+ total={total}
+ showTotal
+ onPreviousPage={() => onPageChange(page - 1)}
+ onNextPage={() => onPageChange(page + 1)}
+ />
+ </Flex>
+ )}
+ </Stack>
+ );
+}
+
+type DataAppLogTableContentProps = {
+ error: unknown;
+ isLoaded: boolean;
+ isFetching: boolean;
+ instance: TreeTableInstance<LogRow>;
+ skeletonColumnWidths: number[];
+};
+
+function DataAppLogTableContent({
+ error,
+ isLoaded,
+ isFetching,
+ instance,
+ skeletonColumnWidths,
+}: DataAppLogTableContentProps) {
+ if (error !== undefined && error !== null) {
+ return (
+ <Flex mih="60vh" align="center" justify="center">
+ <LoadingAndErrorWrapper loading={false} error={error} />
+ </Flex>
+ );
+ }
+
+ if (!isLoaded) {
+ return <TreeTableSkeleton columnWidths={skeletonColumnWidths} />;
+ }
+
+ return (
+ <>
+ <LoadingOverlay visible={isFetching} />
+ <TreeTable
+ instance={instance}
+ hierarchical={false}
+ ariaLabel={t`Data app activity`}
+ emptyState={<MonitorEmptyState label={t`No activity found`} />}
+ getRowProps={() => ({ "data-testid": "data-app-log-row" })}
+ />
+ </>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppsAnalyticsPage.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppsAnalyticsPage.tsx
new file mode 100644
index 00000000000..17c9e9f9bc1
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppsAnalyticsPage.tsx
@@ -0,0 +1,156 @@
+import { useMemo } from "react";
+import { t } from "ttag";
+
+import { EmptyState } from "metabase/common/components/EmptyState";
+import { useUrlState } from "metabase/common/hooks/use-url-state";
+import { useLocation } from "metabase/router";
+import { useSetting } from "metabase/settings";
+import { AiAnalyticsSectionLayout } from "metabase-enterprise/monitor/ai-auditing/components/AiAnalyticsSectionLayout";
+import { NewQuestionButton } from "metabase-enterprise/monitor/ai-auditing/components/NewQuestionButton";
+import {
+ DATA_APP_LOG_VIEW,
+ buildDataAppLogCountQuery,
+ getMissingDataAppLogColumns,
+ scopeToDataApps,
+} from "metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils";
+import { dataAppsAnalyticsUrlStateConfig } from "metabase-enterprise/monitor/ai-auditing/data-apps-analytics/url-state";
+import {
+ ConversationFilters as DataAppsAnalyticsFilterBar,
+ useFilterOptions,
+} from "metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters";
+import { useAuditTable } from "metabase-enterprise/monitor/ai-auditing/metabot-analytics/hooks/useAuditTable";
+import { useHasData } from "metabase-enterprise/monitor/ai-auditing/metabot-analytics/hooks/useHasData";
+
+import { DataAppFilterSelect } from "./DataAppFilterSelect";
+import { DataAppLogTable } from "./DataAppLogTable";
+import { EntityTypeFilterSelect } from "./EntityTypeFilterSelect";
+
+export function DataAppsAnalyticsPage() {
+ const location = useLocation();
+ const [
+ { date, user, app, type, page, sort_column, sort_direction },
+ { patchUrlState },
+ ] = useUrlState(location, dataAppsAnalyticsUrlStateConfig);
+
+ const { dateFilter, userId, userOptions } = useFilterOptions(
+ { date, user, group: null, tenant: null },
+ { hasGroupAndTenantFilters: false },
+ );
+
+ const hasPii = useSetting("analytics-pii-retention-enabled") === true;
+ const audit = useAuditTable(DATA_APP_LOG_VIEW);
+ const missingColumns = useMemo(
+ () =>
+ audit.provider && audit.table
+ ? getMissingDataAppLogColumns({
+ provider: audit.provider,
+ table: audit.table,
+ })
+ : [],
+ [audit.provider, audit.table],
+ );
+ // Without these columns the page can't scope the log to data apps, so it queries nothing.
+ const hasFilterColumns = missingColumns.length === 0;
+ const provider = hasFilterColumns ? audit.provider : null;
+ const table = hasFilterColumns ? audit.table : null;
+ const missingColumnsError = hasFilterColumns
+ ? undefined
+ : t`The query log is missing the columns this page filters on: ${missingColumns.join(", ")}.`;
+
+ const filters = useMemo(
+ () => ({
+ dateFilter,
+ userId,
+ dataAppName: app ?? undefined,
+ entityType: type ?? undefined,
+ }),
+ [app, dateFilter, type, userId],
+ );
+ const sortingOptions = useMemo(
+ () => ({ sort_column, sort_direction }),
+ [sort_column, sort_direction],
+ );
+
+ const countQuery = useMemo(
+ () =>
+ provider && table
+ ? buildDataAppLogCountQuery({ provider, table, ...filters })
+ : null,
+ [provider, table, filters],
+ );
+ const { isInitialLoading, isRefetching, hasData, count, error } =
+ useHasData(countQuery);
+ const showEmpty = !isInitialLoading && !isRefetching && !hasData;
+
+ return (
+ <AiAnalyticsSectionLayout
+ title={t`Data app analytics`}
+ filtersAction={
+ hasFilterColumns && (
+ <NewQuestionButton
+ viewName={DATA_APP_LOG_VIEW}
+ scopeQuery={scopeToDataApps}
+ />
+ )
+ }
+ filters={
+ <DataAppsAnalyticsFilterBar
+ date={date}
+ onDateChange={(val) => patchUrlState({ date: val, page: 0 })}
+ userFilter={{
+ value: user,
+ options: userOptions,
+ onChange: (val) => patchUrlState({ user: val, page: 0 }),
+ }}
+ // Data app activity is scoped by app and user, so there's no group or tenant filter.
+ extraFilter={
+ <>
+ <DataAppFilterSelect
+ value={app}
+ onChange={(val) => patchUrlState({ app: val, page: 0 })}
+ provider={provider}
+ table={table}
+ dateFilter={dateFilter}
+ />
+ <EntityTypeFilterSelect
+ value={type}
+ onChange={(val) => patchUrlState({ type: val, page: 0 })}
+ />
+ </>
+ }
+ />
+ }
+ emptyState={
+ <EmptyState
+ icon="audit"
+ title={t`No data app activity`}
+ message={t`Questions and actions that data apps run will show up here. Try widening the date range or check back once people start using your data apps.`}
+ />
+ }
+ error={error ?? audit.error ?? missingColumnsError}
+ isInitialLoading={isInitialLoading}
+ isTableRoute
+ showEmpty={showEmpty}
+ >
+ <DataAppLogTable
+ provider={provider}
+ table={table}
+ filters={filters}
+ hasPii={hasPii}
+ page={page}
+ total={count}
+ onPageChange={(newPage) =>
+ patchUrlState({ page: newPage }, { immediate: true })
+ }
+ sortingOptions={sortingOptions}
+ onSortingOptionsChange={(newSorting) =>
+ patchUrlState({
+ sort_column: newSorting.sort_column,
+ sort_direction: newSorting.sort_direction,
+ page: 0,
+ })
+ }
+ />
+ </AiAnalyticsSectionLayout>
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppsAnalyticsPage.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppsAnalyticsPage.unit.spec.tsx
new file mode 100644
index 00000000000..fbc120b5e72
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/DataAppsAnalyticsPage.unit.spec.tsx
@@ -0,0 +1,721 @@
+import userEvent from "@testing-library/user-event";
+import fetchMock from "fetch-mock";
+
+import { setupEnterprisePlugins } from "__support__/enterprise";
+import {
+ setupGroupsEndpoint,
+ setupListDataAppsEndpoint,
+ setupUsersEndpoints,
+} from "__support__/server-mocks";
+import { mockSettings } from "__support__/settings";
+import { createMockState } from "__support__/state";
+import {
+ mockGetBoundingClientRect,
+ renderWithProviders,
+ screen,
+ waitFor,
+ within,
+} from "__support__/ui";
+import { deserializeCardFromUrl } from "metabase/common/utils/card";
+import { PAGE_SIZE } from "metabase/monitor/constants";
+import { Route } from "metabase/router";
+import * as Urls from "metabase/urls";
+import { AUDIT_DB_ID } from "metabase-enterprise/monitor/ai-auditing/metabot-analytics/constants";
+import type { Database, Dataset, Field } from "metabase-types/api";
+import {
+ createMockColumn,
+ createMockDataApp,
+ createMockDatabase,
+ createMockDataset,
+ createMockDatasetData,
+ createMockField,
+ createMockGroup,
+ createMockTable,
+ createMockTokenFeatures,
+ createMockUser,
+} from "metabase-types/api/mocks";
+import { isObject } from "metabase-types/guards";
+
+import { DataAppsAnalyticsPage } from "./DataAppsAnalyticsPage";
+
+const QUERY_LOG_TABLE_ID = 3001;
+
+// The ids `buildTable` gives the fields.
+const fieldId = (index: number) => QUERY_LOG_TABLE_ID * 100 + index;
+const FIELD_IDS = {
+ entity_id: fieldId(0),
+ started_at: fieldId(1),
+ embedding_client: fieldId(2),
+ embedding_client_identifier: fieldId(3),
+ user_id: fieldId(4),
+ action_id: fieldId(5),
+};
+
+const BASE_TYPE = {
+ text: "type/Text",
+ integer: "type/Integer",
+ float: "type/Float",
+ boolean: "type/Boolean",
+ dateTime: "type/DateTimeWithLocalTZ",
+} as const;
+
+type FieldSpec = [
+ type: keyof typeof BASE_TYPE,
+ name: string,
+ semantic_type: Field["semantic_type"],
+];
+
+const QUERY_LOG_FIELDS: FieldSpec[] = [
+ ["integer", "entity_id", "type/PK"],
+ ["dateTime", "started_at", "type/CreationTimestamp"],
+ ["text", "embedding_client", "type/Category"],
+ ["text", "embedding_client_identifier", "type/Category"],
+ ["integer", "user_id", "type/FK"],
+ ["integer", "action_id", null],
+ ["float", "running_time_seconds", null],
+ ["integer", "result_rows", "type/Quantity"],
+ ["text", "error", null],
+ ["text", "sanitized_user_agent", null],
+ ["text", "user_agent", null],
+ ["text", "metabase_version", null],
+ ["text", "card_qualified_id", "type/FK"],
+ ["text", "database_qualified_id", "type/FK"],
+ ["text", "action_qualified_id", "type/FK"],
+ ["text", "query", "type/SerializedJSON"],
+];
+
+const buildTable = (id: number, name: string, fields: FieldSpec[]) =>
+ createMockTable({
+ id,
+ db_id: AUDIT_DB_ID,
+ schema: "public",
+ name,
+ display_name: name,
+ fields: fields.map(([type, fieldName, semantic_type], i) =>
+ createMockField({
+ id: id * 100 + i,
+ table_id: id,
+ name: fieldName,
+ display_name: fieldName,
+ fingerprint: null,
+ base_type: BASE_TYPE[type],
+ effective_type: BASE_TYPE[type],
+ semantic_type,
+ }),
+ ),
+ });
+
+const buildAuditDatabase = (fields: FieldSpec[]): Database =>
+ createMockDatabase({
+ id: AUDIT_DB_ID,
+ name: "Audit DB",
+ tables: [buildTable(QUERY_LOG_TABLE_ID, "v_query_log", fields)],
+ });
+
+const USER_AGENT =
+ "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/141.0 Safari/537.36";
+const SANITIZED_USER_AGENT = "Browser (Chrome/OS X)";
+const QUERY = '{"lib/type":"mbql/query","stages":[{"source-card":306}]}';
+
+// The first row reads a question, the second runs an action.
+const logDataset: Dataset = createMockDataset({
+ data: createMockDatasetData({
+ cols: [
+ "started_at",
+ "embedding_client_identifier",
+ "action_id",
+ "sanitized_user_agent",
+ "user_agent",
+ "metabase_version",
+ ]
+ .map((name) => createMockColumn({ name, display_name: name }))
+ .concat([
+ // The query processor returns a remapped id alongside the column holding its name.
+ createMockColumn({ name: "user_id", remapped_to: "full_name" }),
+ createMockColumn({ name: "full_name", remapped_from: "user_id" }),
+ createMockColumn({ name: "card_qualified_id", remapped_to: "name" }),
+ createMockColumn({ name: "name", remapped_from: "card_qualified_id" }),
+ createMockColumn({ name: "query" }),
+ ]),
+ rows: [
+ [
+ "2026-10-01T10:00:00Z",
+ "product-reviews",
+ null,
+ SANITIZED_USER_AGENT,
+ USER_AGENT,
+ "v1.0.5-SNAPSHOT",
+ 1,
+ "Ada Lovelace",
+ "card_306",
+ "Product reviews",
+ QUERY,
+ ],
+ [
+ "2026-10-01T09:00:00Z",
+ "unknown-app",
+ 5,
+ null,
+ null,
+ "v1.0.5-SNAPSHOT",
+ 2,
+ "Grace Hopper",
+ null,
+ null,
+ null,
+ ],
+ ],
+ }),
+ database_id: AUDIT_DB_ID,
+ row_count: 2,
+ running_time: 1,
+});
+
+const createCountDataset = (total: number): Dataset =>
+ createMockDataset({
+ data: createMockDatasetData({
+ cols: [createMockColumn({ name: "count", display_name: "Count" })],
+ rows: [[total]],
+ }),
+ database_id: AUDIT_DB_ID,
+ row_count: 1,
+ running_time: 1,
+ });
+
+// The dropdown's distinct apps: one still installed, one removed since.
+const loggedDataAppsDataset: Dataset = createMockDataset({
+ data: createMockDatasetData({
+ cols: [createMockColumn({ name: "embedding_client_identifier" })],
+ rows: [["product-reviews"], ["store-desk"]],
+ }),
+ database_id: AUDIT_DB_ID,
+ row_count: 2,
+ running_time: 1,
+});
+
+type DatasetStage = Record<string | number | symbol, unknown>;
+
+function getFirstStage(body: unknown): DatasetStage | undefined {
+ if (typeof body !== "string") {
+ return undefined;
+ }
+ const query: unknown = JSON.parse(body);
+ if (!isObject(query) || !Array.isArray(query.stages)) {
+ return undefined;
+ }
+ const stages: unknown[] = query.stages;
+ const [stage] = stages;
+ return isObject(stage) ? stage : undefined;
+}
+
+const isLoggedDataAppsStage = (stage: DatasetStage | undefined) =>
+ stage?.breakout !== undefined && stage.aggregation === undefined;
+
+const isCountStage = (stage: DatasetStage | undefined) =>
+ stage?.aggregation !== undefined && stage.breakout === undefined;
+
+const createFailure = (message: string) => ({
+ status: 500,
+ body: { message },
+});
+
+type SetupOpts = {
+ fields?: FieldSpec[];
+ /** The number of records the count query reports. */
+ total?: number;
+ failingRequest?: "metadata" | "count" | "rows";
+ initialRoute?: string;
+ hasPii?: boolean;
+};
+
+function setup({
+ fields = QUERY_LOG_FIELDS,
+ total = 2,
+ failingRequest,
+ initialRoute = Urls.monitorAiAuditingDataApps(),
+ hasPii = false,
+}: SetupOpts = {}) {
+ // TreeTable measures its rows via the DOM; jsdom needs a stubbed rect to render them.
+ mockGetBoundingClientRect({ width: 100, height: 100 });
+ setupEnterprisePlugins();
+ const auditDatabase = buildAuditDatabase(fields);
+ fetchMock.get(
+ `path:/api/database/${AUDIT_DB_ID}/metadata`,
+ failingRequest === "metadata"
+ ? createFailure("Metadata failed")
+ : auditDatabase,
+ );
+ fetchMock.post("path:/api/dataset/query_metadata", {
+ databases: [auditDatabase],
+ tables: auditDatabase.tables ?? [],
+ fields: (auditDatabase.tables ?? []).flatMap((table) => table.fields ?? []),
+ });
+ fetchMock.post(
+ "path:/api/dataset",
+ (callLog) => {
+ const stage = getFirstStage(callLog.options.body);
+ if (isLoggedDataAppsStage(stage)) {
+ return loggedDataAppsDataset;
+ }
+ if (isCountStage(stage)) {
+ return failingRequest === "count"
+ ? createFailure("Count failed")
+ : createCountDataset(total);
+ }
+ return failingRequest === "rows"
+ ? createFailure("Rows failed")
+ : logDataset;
+ },
+ { name: "dataset" },
+ );
+ setupUsersEndpoints([
+ createMockUser({ id: 1, first_name: "Ada", last_name: "Lovelace" }),
+ ]);
+ setupGroupsEndpoint([createMockGroup({ id: 1, name: "All Users" })]);
+ setupListDataAppsEndpoint([
+ createMockDataApp({
+ id: 1,
+ name: "product-reviews",
+ display_name: "Reviews",
+ }),
+ createMockDataApp({
+ id: 2,
+ name: "store-archive",
+ display_name: "Archive",
+ enabled: false,
+ }),
+ ]);
+
+ return renderWithProviders(
+ <Route
+ path={Urls.monitorAiAuditingDataApps()}
+ element={<DataAppsAnalyticsPage />}
+ />,
+ {
+ initialRoute,
+ withRouter: true,
+ storeInitialState: createMockState({
+ settings: mockSettings({
+ "token-features": createMockTokenFeatures({
+ audit_app: true,
+ "data-apps": true,
+ }),
+ "analytics-pii-retention-enabled": hasPii,
+ }),
+ }),
+ },
+ );
+}
+
+function getDatasetStages(): DatasetStage[] {
+ return fetchMock.callHistory
+ .calls("dataset")
+ .map((call) => getFirstStage(call.options?.body))
+ .filter((stage): stage is DatasetStage => stage !== undefined);
+}
+
+/** A stage's MBQL 5 clauses under `key`, each `[operator, options, ...args]`. */
+function getClauses(
+ stage: DatasetStage,
+ key: "filters" | "order-by",
+): unknown[][] {
+ const clauses = stage[key];
+ if (!Array.isArray(clauses)) {
+ return [];
+ }
+ const items: unknown[] = clauses;
+ return items.filter((clause): clause is unknown[] => Array.isArray(clause));
+}
+
+/** The field id a `["field", options, id]` reference points at. */
+function getFieldRefId(fieldRef: unknown): unknown {
+ if (!Array.isArray(fieldRef)) {
+ return undefined;
+ }
+ const parts: unknown[] = fieldRef;
+ return parts[2];
+}
+
+/**
+ * The values a stage's equality filter on `fieldId` matches, or `undefined` without one.
+ * MBQL writes a single value as `=` and several as `in`.
+ */
+function getEqualsFilterValues(stage: DatasetStage, fieldId: number) {
+ const clause = getClauses(stage, "filters").find(
+ ([operator, , fieldRef]) =>
+ (operator === "=" || operator === "in") &&
+ getFieldRefId(fieldRef) === fieldId,
+ );
+ return clause?.slice(3);
+}
+
+function getFilterOperator(stage: DatasetStage, fieldId: number) {
+ return getClauses(stage, "filters").find(
+ ([, , fieldRef]) => getFieldRefId(fieldRef) === fieldId,
+ )?.[0];
+}
+
+const getRowsStages = () =>
+ getDatasetStages().filter((stage) => stage.page !== undefined);
+
+const getHeaders = (table: HTMLElement) =>
+ within(table)
+ .getAllByRole("columnheader")
+ .map((header) => header.textContent);
+
+describe("DataAppsAnalyticsPage", () => {
+ it("shows the data app, entity type, user, and date filters, but no group filter or tabs", async () => {
+ setup();
+
+ await screen.findByRole("heading", { name: "Data app analytics" });
+ expect(screen.getByTestId("data-app-filter-select")).toHaveValue(
+ "All data apps",
+ );
+ expect(screen.getByTestId("entity-type-filter-select")).toHaveValue(
+ "All entity types",
+ );
+ expect(screen.getByTestId("conversation-filters-user-select")).toHaveValue(
+ "All users",
+ );
+ expect(
+ screen.getByTestId("conversation-filters-date-select"),
+ ).toBeInTheDocument();
+ expect(
+ screen.queryByTestId("conversation-filters-group-select"),
+ ).not.toBeInTheDocument();
+ expect(screen.queryByRole("navigation")).not.toBeInTheDocument();
+ });
+
+ it("offers to query the query log's data app records in the notebook", async () => {
+ setup();
+
+ const link = await screen.findByRole("link", { name: /Query this data/ });
+ const href = link.getAttribute("href") ?? "";
+ const [, serializedCard = ""] = href.split("#");
+ const stage = getFirstStage(
+ JSON.stringify(deserializeCardFromUrl(serializedCard).dataset_query),
+ );
+ expect(href).toContain("/question/notebook#");
+ expect(stage?.["source-table"]).toBe(QUERY_LOG_TABLE_ID);
+ expect(getClauses(stage ?? {}, "filters")).toHaveLength(1);
+ expect(
+ getEqualsFilterValues(stage ?? {}, FIELD_IDS.embedding_client),
+ ).toEqual(["data-app"]);
+ });
+
+ it("doesn't load the group and tenant options it has no filter for", async () => {
+ setup();
+
+ await screen.findByRole("treegrid", { name: "Data app activity" });
+ expect(fetchMock.callHistory.called("path:/api/permissions/group")).toBe(
+ false,
+ );
+ });
+
+ it("groups the columns by meaning: when, which app, who ran what, how it went, then the details", async () => {
+ setup({ hasPii: true });
+
+ const table = await screen.findByRole("treegrid", {
+ name: "Data app activity",
+ });
+ expect(getHeaders(table)).toEqual([
+ "Started at",
+ "Identifier",
+ "Name",
+ "User",
+ "Entity type",
+ "Question",
+ "Action",
+ "Running time (s)",
+ "Result rows",
+ "Database",
+ "Query",
+ "Metabase version",
+ "User agent",
+ "Sanitized user agent",
+ "IP address",
+ "Error",
+ ]);
+ });
+
+ it("shows each record's entity type, data app, and user", async () => {
+ setup();
+
+ const table = await screen.findByRole("treegrid", {
+ name: "Data app activity",
+ });
+ const [questionRow, actionRow] =
+ await within(table).findAllByTestId("data-app-log-row");
+ expect(within(questionRow).getByText("Question")).toBeInTheDocument();
+ expect(within(questionRow).getByText("Reviews")).toBeInTheDocument();
+ expect(
+ within(questionRow).getByText("product-reviews"),
+ ).toBeInTheDocument();
+ expect(within(questionRow).getByText("Ada Lovelace")).toBeInTheDocument();
+ expect(within(actionRow).getByText("Action")).toBeInTheDocument();
+ // Not in the user list the filter loads: the log names the user itself.
+ expect(within(actionRow).getByText("Grace Hopper")).toBeInTheDocument();
+ // An app that's no longer installed has no name, only its identifier.
+ expect(within(actionRow).getByText("unknown-app")).toBeInTheDocument();
+ expect(within(actionRow).queryByText("Reviews")).not.toBeInTheDocument();
+ });
+
+ it("shows the referenced content by name, and the query itself", async () => {
+ setup();
+
+ const table = await screen.findByRole("treegrid", {
+ name: "Data app activity",
+ });
+ const [row] = await within(table).findAllByTestId("data-app-log-row");
+ expect(within(row).getByText("Product reviews")).toBeInTheDocument();
+ expect(within(row).queryByText("card_306")).not.toBeInTheDocument();
+ expect(within(row).getByText(QUERY)).toBeInTheDocument();
+ expect(within(row).getByText("v1.0.5-SNAPSHOT")).toBeInTheDocument();
+ });
+
+ it("shows each record's user agents while PII retention is on", async () => {
+ setup({ hasPii: true });
+
+ const table = await screen.findByRole("treegrid", {
+ name: "Data app activity",
+ });
+ const [row] = await within(table).findAllByTestId("data-app-log-row");
+ expect(within(row).getByText(SANITIZED_USER_AGENT)).toBeInTheDocument();
+ expect(within(row).getByText(USER_AGENT)).toBeInTheDocument();
+ });
+
+ it("hides the user agents and IP address, which aren't recorded, while PII retention is off", async () => {
+ setup({ hasPii: false });
+
+ const table = await screen.findByRole("treegrid", {
+ name: "Data app activity",
+ });
+ await within(table).findAllByTestId("data-app-log-row");
+ ["User agent", "Sanitized user agent", "IP address"].forEach((name) => {
+ expect(
+ within(table).queryByRole("columnheader", { name }),
+ ).not.toBeInTheDocument();
+ });
+ });
+
+ it("only queries the query log's published data-app records, leaving out previews", async () => {
+ setup();
+
+ await screen.findByRole("treegrid", { name: "Data app activity" });
+ await waitFor(() => {
+ expect(getRowsStages()).not.toHaveLength(0);
+ });
+
+ const stages = getDatasetStages();
+ expect(stages.some((stage) => stage.aggregation !== undefined)).toBe(true);
+ stages.forEach((stage) => {
+ expect(stage["source-table"]).toBe(QUERY_LOG_TABLE_ID);
+ expect(getEqualsFilterValues(stage, FIELD_IDS.embedding_client)).toEqual([
+ "data-app",
+ ]);
+ expect(getFilterOperator(stage, FIELD_IDS.action_id)).toBeUndefined();
+ });
+ });
+
+ it("shows an error, and queries nothing, when the query log has no column to scope it to data apps", async () => {
+ setup({
+ fields: QUERY_LOG_FIELDS.filter(
+ ([, name]) => name !== "embedding_client",
+ ),
+ });
+
+ expect(
+ await screen.findByText(
+ "The query log is missing the columns this page filters on: embedding_client.",
+ ),
+ ).toBeInTheDocument();
+ expect(fetchMock.callHistory.called("dataset")).toBe(false);
+ expect(
+ screen.queryByRole("link", { name: /Query this data/ }),
+ ).not.toBeInTheDocument();
+ });
+
+ it.each([
+ { label: "Action", type: "action", operator: "not-null" },
+ { label: "Question", type: "question", operator: "is-null" },
+ ])("scopes the log to $label records", async ({ label, type, operator }) => {
+ const { router } = setup();
+
+ await screen.findByRole("treegrid", { name: "Data app activity" });
+ await userEvent.click(screen.getByTestId("entity-type-filter-select"));
+ await userEvent.click(await screen.findByRole("option", { name: label }));
+
+ await waitFor(() => {
+ const scopedStages = getDatasetStages().filter(
+ (stage) => getFilterOperator(stage, FIELD_IDS.action_id) !== undefined,
+ );
+ // Both the count and the rows are scoped, so the total and the pages agree.
+ expect(
+ scopedStages.map((stage) => [
+ stage.page !== undefined,
+ getFilterOperator(stage, FIELD_IDS.action_id),
+ ]),
+ ).toEqual(
+ expect.arrayContaining([
+ [false, operator],
+ [true, operator],
+ ]),
+ );
+ });
+ await waitFor(() => {
+ expect(router?.location.search).toContain(`type=${type}`);
+ });
+ });
+
+ it("offers the installed apps, disabled ones included, and the removed apps with activity in the date range by their identifier, in sections of their own", async () => {
+ setup();
+
+ await screen.findByRole("treegrid", { name: "Data app activity" });
+ await userEvent.click(screen.getByTestId("data-app-filter-select"));
+ expect(
+ (await screen.findAllByRole("option")).map(
+ (option) => option.textContent,
+ ),
+ ).toEqual(["All data apps", "Reviews", "Archive", "store-desk"]);
+ const getSectionOptions = (name: string) =>
+ within(screen.getByRole("group", { name }))
+ .getAllByRole("option")
+ .map((option) => option.textContent);
+ expect(getSectionOptions("Installed")).toEqual(["Reviews", "Archive"]);
+ expect(getSectionOptions("Removed")).toEqual(["store-desk"]);
+
+ await userEvent.click(screen.getByRole("option", { name: "store-desk" }));
+ await waitFor(() => {
+ const scopedStage = getRowsStages().find(
+ (stage) =>
+ getEqualsFilterValues(
+ stage,
+ FIELD_IDS.embedding_client_identifier,
+ ) !== undefined,
+ );
+ expect(
+ getEqualsFilterValues(
+ scopedStage ?? {},
+ FIELD_IDS.embedding_client_identifier,
+ ),
+ ).toEqual(["store-desk"]);
+ });
+ });
+
+ it("scopes the log to the selected data app and user", async () => {
+ const { router } = setup();
+
+ await screen.findByRole("treegrid", { name: "Data app activity" });
+
+ await userEvent.click(screen.getByTestId("data-app-filter-select"));
+ await userEvent.click(
+ await screen.findByRole("option", { name: "Reviews" }),
+ );
+ await userEvent.click(
+ screen.getByTestId("conversation-filters-user-select"),
+ );
+ await userEvent.click(
+ await screen.findByRole("option", { name: "Ada Lovelace" }),
+ );
+
+ await waitFor(() => {
+ const scopedStage = getRowsStages().find(
+ (stage) =>
+ getEqualsFilterValues(stage, FIELD_IDS.user_id) !== undefined,
+ );
+ expect(scopedStage).toBeDefined();
+ expect(
+ getEqualsFilterValues(
+ scopedStage ?? {},
+ FIELD_IDS.embedding_client_identifier,
+ ),
+ ).toEqual(["product-reviews"]);
+ expect(
+ getEqualsFilterValues(scopedStage ?? {}, FIELD_IDS.user_id),
+ ).toEqual([1]);
+ });
+ await waitFor(() => {
+ expect(router?.location.search).toContain("app=product-reviews");
+ });
+ });
+
+ it("orders the log newest first, with the id as a tiebreaker", async () => {
+ setup();
+
+ await waitFor(() => {
+ const [stage] = getRowsStages();
+ expect(stage).toBeDefined();
+ expect(
+ getClauses(stage ?? {}, "order-by").map(([direction, , fieldRef]) => [
+ direction,
+ getFieldRefId(fieldRef),
+ ]),
+ ).toEqual([
+ ["desc", FIELD_IDS.started_at],
+ ["desc", FIELD_IDS.entity_id],
+ ]);
+ });
+ });
+
+ it("pages through the log, keeping the page in the URL", async () => {
+ const { router } = setup({ total: PAGE_SIZE + 1 });
+
+ await userEvent.click(await screen.findByLabelText("Next page"));
+ await waitFor(() => {
+ expect(getRowsStages().at(-1)?.page).toEqual({
+ page: 2,
+ items: PAGE_SIZE,
+ });
+ });
+ await waitFor(() => {
+ expect(router?.location.search).toContain("page=1");
+ });
+
+ await userEvent.click(screen.getByLabelText("Previous page"));
+ await waitFor(() => {
+ expect(getRowsStages().at(-1)?.page).toEqual({
+ page: 1,
+ items: PAGE_SIZE,
+ });
+ });
+ await waitFor(() => {
+ expect(router?.location.search).not.toContain("page=");
+ });
+ });
+
+ it("shows an empty state, keeping the filters, when there is no data app activity", async () => {
+ setup({ total: 0 });
+
+ expect(await screen.findByText("No data app activity")).toBeInTheDocument();
+ expect(screen.getByTestId("data-app-filter-select")).toBeInTheDocument();
+ expect(screen.getByTestId("entity-type-filter-select")).toBeInTheDocument();
+ expect(
+ screen.queryByRole("treegrid", { name: "Data app activity" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("shows the error when counting the records fails", async () => {
+ setup({ failingRequest: "count" });
+
+ expect(await screen.findByText("Count failed")).toBeInTheDocument();
+ expect(
+ screen.queryByRole("treegrid", { name: "Data app activity" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("shows the error in the table, keeping the filters, when loading the records fails", async () => {
+ setup({ failingRequest: "rows" });
+
+ const table = await screen.findByTestId("data-app-log-table");
+ expect(await within(table).findByText("Rows failed")).toBeInTheDocument();
+ expect(screen.getByTestId("data-app-filter-select")).toBeInTheDocument();
+ expect(screen.queryByLabelText("pagination")).not.toBeInTheDocument();
+ });
+
+ it("shows the error, and queries nothing, when the query log's metadata doesn't load", async () => {
+ setup({ failingRequest: "metadata" });
+
+ expect(await screen.findByText("Metadata failed")).toBeInTheDocument();
+ expect(fetchMock.callHistory.called("dataset")).toBe(false);
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/EntityTypeFilterSelect.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/EntityTypeFilterSelect.tsx
new file mode 100644
index 00000000000..3dca82cb334
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/EntityTypeFilterSelect.tsx
@@ -0,0 +1,48 @@
+import { t } from "ttag";
+
+import { FILTER_WIDTH } from "metabase/monitor/constants";
+import { Select } from "metabase/ui";
+import {
+ DATA_APP_ENTITY_TYPES,
+ type DataAppEntityType,
+ parseDataAppEntityType,
+} from "metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils";
+
+const ALL_ENTITY_TYPES = "";
+
+export function getEntityTypeLabel(entityType: DataAppEntityType): string {
+ switch (entityType) {
+ case "question":
+ return t`Question`;
+ case "action":
+ return t`Action`;
+ }
+}
+
+type EntityTypeFilterSelectProps = {
+ value: DataAppEntityType | null;
+ onChange: (value: DataAppEntityType | null) => void;
+};
+
+export function EntityTypeFilterSelect({
+ value,
+ onChange,
+}: EntityTypeFilterSelectProps) {
+ return (
+ <Select
+ data={[
+ { value: ALL_ENTITY_TYPES, label: t`All entity types` },
+ ...DATA_APP_ENTITY_TYPES.map((entityType) => ({
+ value: entityType,
+ label: getEntityTypeLabel(entityType),
+ })),
+ ]}
+ value={value ?? ALL_ENTITY_TYPES}
+ onChange={(val) => onChange(parseDataAppEntityType(val))}
+ aria-label={t`Entity type`}
+ w={FILTER_WIDTH}
+ bdrs="xs"
+ data-testid="entity-type-filter-select"
+ />
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/utils.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/utils.ts
new file mode 100644
index 00000000000..606e37c079e
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/utils.ts
@@ -0,0 +1,63 @@
+import {
+ DATA_APP_LOG_ID_COLUMN,
+ DEFAULT_SORTING,
+ type DataAppLogColumn,
+} from "metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils";
+import type {
+ DatasetColumn,
+ DatasetData,
+ RowValue,
+ SortingOptions,
+} from "metabase-types/api";
+
+export type LogRow = { id: string } & Partial<
+ Record<DataAppLogColumn, RowValue>
+>;
+
+// A sort can outlive its column, e.g. a PII column after retention was turned off.
+export function getEffectiveSorting(
+ sorting: SortingOptions<DataAppLogColumn>,
+ sortableColumns: readonly DataAppLogColumn[],
+): SortingOptions<DataAppLogColumn> {
+ return sortableColumns.includes(sorting.sort_column)
+ ? sorting
+ : DEFAULT_SORTING;
+}
+
+// Warehouses return column names in upper or lower case, so they're matched case-insensitively.
+// A column remapped to a human-readable one (a question's id to its name) reads from that one.
+function getColumnIndexByName(
+ cols: readonly DatasetColumn[],
+): Map<string, number> {
+ const indexByName = new Map(
+ cols.map((col, index) => [col.name.toLowerCase(), index]),
+ );
+ return new Map(
+ cols.map((col, index) => {
+ const remappedIndex =
+ col.remapped_to === undefined
+ ? undefined
+ : indexByName.get(col.remapped_to.toLowerCase());
+ return [col.name.toLowerCase(), remappedIndex ?? index];
+ }),
+ );
+}
+
+export function getLogRows(
+ { cols, rows }: Pick<DatasetData, "cols" | "rows">,
+ columns: readonly DataAppLogColumn[],
+ page: number,
+): LogRow[] {
+ const columnIndex = getColumnIndexByName(cols);
+ const idIndex = columnIndex.get(DATA_APP_LOG_ID_COLUMN);
+ return rows.map((row, rowIndex) => {
+ const values = Object.fromEntries(
+ columns.map((column) => {
+ const index = columnIndex.get(column);
+ return [column, index === undefined ? null : row[index]];
+ }),
+ );
+ const id = idIndex === undefined ? null : row[idIndex];
+ return { id: String(id ?? `${page}-${rowIndex}`), ...values };
+ });
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/utils.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/utils.unit.spec.ts
new file mode 100644
index 00000000000..4321c458950
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/components/utils.unit.spec.ts
@@ -0,0 +1,83 @@
+import {
+ DEFAULT_SORTING,
+ type DataAppLogColumn,
+} from "metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils";
+import type { SortingOptions } from "metabase-types/api";
+import { createMockColumn } from "metabase-types/api/mocks";
+
+import { getEffectiveSorting, getLogRows } from "./utils";
+
+describe("getEffectiveSorting", () => {
+ const sorting: SortingOptions<DataAppLogColumn> = {
+ sort_column: "result_rows",
+ sort_direction: "asc",
+ };
+
+ it("keeps a sort on a sortable column", () => {
+ expect(getEffectiveSorting(sorting, ["started_at", "result_rows"])).toBe(
+ sorting,
+ );
+ });
+
+ it("falls back to newest first when the sorted column isn't sortable", () => {
+ expect(getEffectiveSorting(sorting, ["started_at"])).toEqual(
+ DEFAULT_SORTING,
+ );
+ });
+});
+
+describe("getLogRows", () => {
+ it("matches the result's columns case-insensitively and keys rows by the record", () => {
+ const rows = getLogRows(
+ {
+ cols: [
+ createMockColumn({ name: "STARTED_AT" }),
+ createMockColumn({ name: "ENTITY_ID" }),
+ ],
+ rows: [["2026-10-20T08:00:00Z", "robin"]],
+ },
+ ["started_at"],
+ 0,
+ );
+
+ expect(rows).toEqual([{ id: "robin", started_at: "2026-10-20T08:00:00Z" }]);
+ });
+
+ it("reads a remapped column from the column it's remapped to", () => {
+ const rows = getLogRows(
+ {
+ cols: [
+ createMockColumn({
+ name: "card_qualified_id",
+ remapped_to: "card_name",
+ }),
+ createMockColumn({ name: "card_name" }),
+ createMockColumn({ name: "entity_id" }),
+ ],
+ rows: [["card_1", "Bird sightings", "sparrow"]],
+ },
+ ["card_qualified_id"],
+ 0,
+ );
+
+ expect(rows).toEqual([
+ { id: "sparrow", card_qualified_id: "Bird sightings" },
+ ]);
+ });
+
+ it("leaves a column the result lacks empty and falls back to the row's position on the page", () => {
+ const rows = getLogRows(
+ {
+ cols: [createMockColumn({ name: "user_id" })],
+ rows: [[1], [2]],
+ },
+ ["user_id", "ip_address"],
+ 3,
+ );
+
+ expect(rows).toEqual([
+ { id: "3-0", user_id: 1, ip_address: null },
+ { id: "3-1", user_id: 2, ip_address: null },
+ ]);
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils.ts
new file mode 100644
index 00000000000..c532ac4d70d
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils.ts
@@ -0,0 +1,216 @@
+import type { DateFilterValue } from "metabase/querying/common/types";
+import {
+ applyDateFilter,
+ applyIdFilter,
+ breakoutByColumn,
+ findColumn,
+} from "metabase-enterprise/monitor/query-utils";
+import * as Lib from "metabase-lib";
+import type { SortDirection, SortingOptions } from "metabase-types/api";
+
+// Previews record `data-app-preview` and are left out: that's the author trying the app.
+const DATA_APP_EMBEDDING_CLIENT = "data-app";
+
+// Not the view log: that one only mirrors question reads, while the query log has action runs too.
+export const DATA_APP_LOG_VIEW = "v_query_log";
+
+export const DATA_APP_LOG_ID_COLUMN = "entity_id";
+
+const TIMESTAMP_COLUMN = "started_at";
+
+// The wide query sits late so it doesn't push the rest out of sight.
+export const DATA_APP_LOG_COLUMNS = [
+ "started_at",
+ "embedding_client_identifier",
+ "user_id",
+ // Only an action run records an action, so this tells the entity type.
+ "action_id",
+ "card_qualified_id",
+ "action_qualified_id",
+ "running_time_seconds",
+ "result_rows",
+ "database_qualified_id",
+ "query",
+ "metabase_version",
+ "user_agent",
+ "sanitized_user_agent",
+ "ip_address",
+ "error",
+] as const;
+
+export type DataAppLogColumn = (typeof DATA_APP_LOG_COLUMNS)[number];
+
+const PII_COLUMNS: ReadonlySet<DataAppLogColumn> = new Set([
+ "user_agent",
+ "sanitized_user_agent",
+ "ip_address",
+]);
+
+export function dataAppLogColumnKeys(hasPii: boolean): DataAppLogColumn[] {
+ return DATA_APP_LOG_COLUMNS.filter(
+ (column) => hasPii || !PII_COLUMNS.has(column),
+ );
+}
+
+export const DEFAULT_SORTING: SortingOptions<DataAppLogColumn> = {
+ sort_column: TIMESTAMP_COLUMN,
+ sort_direction: "desc",
+};
+
+export const DATA_APP_ENTITY_TYPES = ["question", "action"] as const;
+
+export type DataAppEntityType = (typeof DATA_APP_ENTITY_TYPES)[number];
+
+export function parseDataAppEntityType(
+ value: unknown,
+): DataAppEntityType | null {
+ return DATA_APP_ENTITY_TYPES.find((type) => type === value) ?? null;
+}
+
+export type DataAppLogFilters = {
+ dateFilter: DateFilterValue;
+ userId?: number;
+ /** The data app's slug. */
+ dataAppName?: string;
+ entityType?: DataAppEntityType;
+};
+
+type DataAppLogSource = {
+ provider: Lib.MetadataProvider;
+ table: Lib.TableMetadata | Lib.CardMetadata;
+};
+
+const DATA_APP_LOG_FILTER_COLUMNS = [
+ "embedding_client",
+ "embedding_client_identifier",
+ "action_id",
+ TIMESTAMP_COLUMN,
+ "user_id",
+];
+
+export function getMissingDataAppLogColumns({
+ provider,
+ table,
+}: DataAppLogSource): string[] {
+ const query = Lib.queryFromTableOrCardMetadata(provider, table);
+ return DATA_APP_LOG_FILTER_COLUMNS.filter(
+ (name) => findColumn(query, name, Lib.filterableColumns) === undefined,
+ );
+}
+
+// Throws instead of skipping the filter: without it the log would show records it should leave out.
+function findFilterColumn(
+ query: Lib.Query,
+ columnName: string,
+): Lib.ColumnMetadata {
+ const column = findColumn(query, columnName, Lib.filterableColumns);
+ if (column === undefined) {
+ throw new Error(`The query log has no ${columnName} column`);
+ }
+ return column;
+}
+
+function applyStringFilter(
+ query: Lib.Query,
+ columnName: string,
+ values: string[],
+): Lib.Query {
+ const column = findFilterColumn(query, columnName);
+ return Lib.filter(
+ query,
+ 0,
+ Lib.stringFilterClause({ operator: "=", column, values, options: {} }),
+ );
+}
+
+export function scopeToDataApps(query: Lib.Query): Lib.Query {
+ return applyStringFilter(query, "embedding_client", [
+ DATA_APP_EMBEDDING_CLIENT,
+ ]);
+}
+
+function applyEntityTypeFilter(
+ query: Lib.Query,
+ entityType: DataAppEntityType | undefined,
+): Lib.Query {
+ if (entityType === undefined) {
+ return query;
+ }
+ const column = findFilterColumn(query, "action_id");
+ return Lib.filter(
+ query,
+ 0,
+ Lib.defaultFilterClause({
+ operator: entityType === "action" ? "not-null" : "is-null",
+ column,
+ }),
+ );
+}
+
+function orderByColumn(
+ query: Lib.Query,
+ columnName: string,
+ direction: SortDirection,
+): Lib.Query {
+ const column = findColumn(query, columnName, Lib.orderableColumns);
+ return column ? Lib.orderBy(query, 0, column, direction) : query;
+}
+
+function buildBaseQuery({
+ provider,
+ table,
+ dateFilter,
+ userId,
+ dataAppName,
+ entityType,
+}: DataAppLogSource & DataAppLogFilters): Lib.Query {
+ let query = Lib.queryFromTableOrCardMetadata(provider, table);
+ query = scopeToDataApps(query);
+ query = applyDateFilter(query, dateFilter, TIMESTAMP_COLUMN);
+ query = applyIdFilter(query, "user_id", userId);
+ query =
+ dataAppName === undefined
+ ? query
+ : applyStringFilter(query, "embedding_client_identifier", [dataAppName]);
+ query = applyEntityTypeFilter(query, entityType);
+ return query;
+}
+
+/** The slugs of the data apps with activity in the date range, removed apps included. */
+export function buildLoggedDataAppsQuery({
+ provider,
+ table,
+ dateFilter,
+}: DataAppLogSource & Pick<DataAppLogFilters, "dateFilter">): Lib.Query {
+ return breakoutByColumn(
+ buildBaseQuery({ provider, table, dateFilter }),
+ "embedding_client_identifier",
+ );
+}
+
+export function buildDataAppLogCountQuery(
+ opts: DataAppLogSource & DataAppLogFilters,
+): Lib.Query {
+ return Lib.aggregateByCount(buildBaseQuery(opts), 0);
+}
+
+type RowsQueryOpts = DataAppLogSource &
+ DataAppLogFilters & {
+ sorting: SortingOptions<DataAppLogColumn>;
+ hasPii: boolean;
+ };
+
+export function buildDataAppLogRowsQuery({
+ sorting,
+ hasPii,
+ ...opts
+}: RowsQueryOpts): Lib.Query {
+ let query = buildBaseQuery(opts);
+ query = orderByColumn(query, sorting.sort_column, sorting.sort_direction);
+ // Breaks ties, so pages can't skip or repeat rows.
+ query = orderByColumn(query, DATA_APP_LOG_ID_COLUMN, "desc");
+ const fields = [...dataAppLogColumnKeys(hasPii), DATA_APP_LOG_ID_COLUMN]
+ .map((name) => findColumn(query, name, Lib.fieldableColumns))
+ .filter((column): column is Lib.ColumnMetadata => column !== undefined);
+ return Lib.withFields(query, 0, fields);
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils.unit.spec.ts
new file mode 100644
index 00000000000..e1a0ff30fe8
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/query-utils.unit.spec.ts
@@ -0,0 +1,113 @@
+import { createMockMetadata } from "__support__/metadata";
+import type { DateFilterValue } from "metabase/querying/common/types";
+import { checkNotNull } from "metabase/utils/types";
+import * as Lib from "metabase-lib";
+import { createMetadataProvider } from "metabase-lib/test-helpers";
+import {
+ createMockDatabase,
+ createMockField,
+ createMockTable,
+} from "metabase-types/api/mocks";
+
+import {
+ buildDataAppLogCountQuery,
+ getMissingDataAppLogColumns,
+} from "./query-utils";
+
+const DATABASE_ID = 13371337;
+const TABLE_ID = 3001;
+
+const DATE_FILTER: DateFilterValue = {
+ type: "relative",
+ value: -30,
+ unit: "day",
+ options: { includeCurrent: true },
+};
+
+const ALL_COLUMNS = [
+ { name: "embedding_client", type: "type/Text" },
+ { name: "embedding_client_identifier", type: "type/Text" },
+ { name: "action_id", type: "type/Integer" },
+ { name: "started_at", type: "type/DateTimeWithLocalTZ" },
+ { name: "user_id", type: "type/Integer" },
+];
+
+function getQueryLogSource(columnNames: string[]) {
+ const table = createMockTable({
+ id: TABLE_ID,
+ db_id: DATABASE_ID,
+ name: "v_query_log",
+ fields: ALL_COLUMNS.filter((column) =>
+ columnNames.includes(column.name),
+ ).map((column, index) =>
+ createMockField({
+ id: TABLE_ID * 100 + index,
+ table_id: TABLE_ID,
+ name: column.name,
+ display_name: column.name,
+ base_type: column.type,
+ effective_type: column.type,
+ }),
+ ),
+ });
+ const metadata = createMockMetadata({
+ databases: [createMockDatabase({ id: DATABASE_ID, tables: [table] })],
+ });
+ const provider = createMetadataProvider({
+ databaseId: DATABASE_ID,
+ metadata,
+ });
+ return {
+ provider,
+ table: checkNotNull(Lib.tableOrCardMetadata(provider, TABLE_ID)),
+ };
+}
+
+const allColumnNames = ALL_COLUMNS.map((column) => column.name);
+
+describe("getMissingDataAppLogColumns", () => {
+ it("names the columns the page filters on that the view lacks", () => {
+ const source = getQueryLogSource(
+ allColumnNames.filter(
+ (name) => name !== "embedding_client" && name !== "action_id",
+ ),
+ );
+
+ expect(getMissingDataAppLogColumns(source)).toEqual([
+ "embedding_client",
+ "action_id",
+ ]);
+ });
+
+ it("names none when the view has them all", () => {
+ expect(
+ getMissingDataAppLogColumns(getQueryLogSource(allColumnNames)),
+ ).toEqual([]);
+ });
+});
+
+describe("buildDataAppLogCountQuery", () => {
+ it("throws rather than leave out the filter that scopes the log to data apps", () => {
+ const source = getQueryLogSource(
+ allColumnNames.filter((name) => name !== "embedding_client"),
+ );
+
+ expect(() =>
+ buildDataAppLogCountQuery({ ...source, dateFilter: DATE_FILTER }),
+ ).toThrow("embedding_client");
+ });
+
+ it("throws rather than leave out the entity type filter", () => {
+ const source = getQueryLogSource(
+ allColumnNames.filter((name) => name !== "action_id"),
+ );
+
+ expect(() =>
+ buildDataAppLogCountQuery({
+ ...source,
+ dateFilter: DATE_FILTER,
+ entityType: "action",
+ }),
+ ).toThrow("action_id");
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/url-state.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/url-state.ts
new file mode 100644
index 00000000000..d57068ba571
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/data-apps-analytics/url-state.ts
@@ -0,0 +1,64 @@
+import {
+ type UrlStateConfig,
+ getFirstParamValue,
+ parsePage,
+ parseSortColumn,
+ parseSortDirection,
+} from "metabase/common/hooks/use-url-state";
+import {
+ type FilterUrlState,
+ filterUrlStateConfig,
+ mergeUrlStateConfig,
+} from "metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/url-state";
+import type { SortDirection } from "metabase-types/api";
+
+import {
+ DATA_APP_LOG_COLUMNS,
+ DEFAULT_SORTING,
+ type DataAppEntityType,
+ type DataAppLogColumn,
+ parseDataAppEntityType,
+} from "./query-utils";
+
+type DataAppLogUrlState = {
+ /** The data app's slug. */
+ app: string | null;
+ type: DataAppEntityType | null;
+ /** Current page of the log table, 0-indexed. */
+ page: number;
+ sort_column: DataAppLogColumn;
+ sort_direction: SortDirection;
+};
+
+export type DataAppsAnalyticsUrlState = FilterUrlState & DataAppLogUrlState;
+
+const dataAppLogUrlStateConfig: UrlStateConfig<DataAppLogUrlState> = {
+ parse: (query) => ({
+ app: getFirstParamValue(query.app)?.trim() || null,
+ type: parseDataAppEntityType(getFirstParamValue(query.type)),
+ page: parsePage(query.page),
+ sort_column: parseSortColumn(
+ query.sort_column,
+ DATA_APP_LOG_COLUMNS,
+ DEFAULT_SORTING.sort_column,
+ ),
+ sort_direction: parseSortDirection(
+ query.sort_direction,
+ DEFAULT_SORTING.sort_direction,
+ ),
+ }),
+ serialize: ({ app, type, page, sort_column, sort_direction }) => ({
+ app: app ?? undefined,
+ type: type ?? undefined,
+ page: page === 0 ? undefined : String(page),
+ sort_column:
+ sort_column === DEFAULT_SORTING.sort_column ? undefined : sort_column,
+ sort_direction:
+ sort_direction === DEFAULT_SORTING.sort_direction
+ ? undefined
+ : sort_direction,
+ }),
+};
+
+export const dataAppsAnalyticsUrlStateConfig: UrlStateConfig<DataAppsAnalyticsUrlState> =
+ mergeUrlStateConfig(filterUrlStateConfig, dataAppLogUrlStateConfig);
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/hooks/useAuditRowCount.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/hooks/useAuditRowCount.ts
index 78701ef5ce5..3c9501789ec 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/hooks/useAuditRowCount.ts
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/hooks/useAuditRowCount.ts
@@ -6,8 +6,8 @@ import {
getTabCount,
} from "metabase/common/components/PillTabNavigation";
import { DEFAULT_DATE_FILTER } from "metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/useFilterOptions";
-import { applyDateFilter } from "metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils";
import type { useAuditTable } from "metabase-enterprise/monitor/ai-auditing/metabot-analytics/hooks/useAuditTable";
+import { applyDateFilter } from "metabase-enterprise/monitor/query-utils";
import * as Lib from "metabase-lib";
export function useAuditRowCount(
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/mcp-analytics/components/McpAnalyticsSectionLayout.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/mcp-analytics/components/McpAnalyticsSectionLayout.tsx
index b91ded9e8ab..442caaedead 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/mcp-analytics/components/McpAnalyticsSectionLayout.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/mcp-analytics/components/McpAnalyticsSectionLayout.tsx
@@ -135,17 +135,26 @@ export function McpAnalyticsSectionLayout() {
<McpToolCallsFilter
date={date}
onDateChange={(val) => patchUrlState({ date: val, page: 0 })}
- user={user}
- onUserChange={(val) => patchUrlState({ user: val, page: 0 })}
- userOptions={userOptions}
- group={group}
- onGroupChange={(val) => patchUrlState({ group: val, page: 0 })}
- groupOptions={groupOptions}
- groupNoFilterValue={groupNoFilterValue}
- tenant={tenant}
- onTenantChange={(val) => patchUrlState({ tenant: val, page: 0 })}
- tenantOptions={tenantOptions}
- hasTenants={hasTenants}
+ userFilter={{
+ value: user,
+ options: userOptions,
+ onChange: (val) => patchUrlState({ user: val, page: 0 }),
+ }}
+ groupFilter={{
+ value: group,
+ options: groupOptions,
+ noFilterValue: groupNoFilterValue,
+ onChange: (val) => patchUrlState({ group: val, page: 0 }),
+ }}
+ tenantFilter={
+ hasTenants
+ ? {
+ value: tenant,
+ options: tenantOptions,
+ onChange: (val) => patchUrlState({ tenant: val, page: 0 }),
+ }
+ : undefined
+ }
/>
}
emptyState={
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/mcp-analytics/query-utils.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/mcp-analytics/query-utils.ts
index 7565c1a372b..5b2cad71c1b 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/mcp-analytics/query-utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/mcp-analytics/query-utils.ts
@@ -5,7 +5,7 @@ import {
breakoutByColumn,
findColumn,
joinGroupMembers,
-} from "metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils";
+} from "metabase-enterprise/monitor/query-utils";
import type {
CardMetadata,
ColumnMetadata,
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/ConversationFilters.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/ConversationFilters.tsx
index 96393c1735a..f34062327a1 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/ConversationFilters.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/ConversationFilters.tsx
@@ -4,6 +4,7 @@ import { P, match } from "ts-pattern";
import { t } from "ttag";
import { dayjs } from "metabase/dayjs";
+import { FILTER_WIDTH } from "metabase/monitor/constants";
import { getOperatorDefaultValue } from "metabase/querying/common/components/DatePicker/SpecificDatePicker/utils";
import type {
DatePickerOperator,
@@ -18,9 +19,6 @@ import {
import { useSetting } from "metabase/settings";
import { Flex, Icon, Popover, Select } from "metabase/ui";
-// width needed to show Previous 12 months option w/ clipping
-const FILTER_WIDTH = 205;
-
const DATE_OPERATORS: DatePickerOperator[] = ["=", ">", "<", "between"];
const RELATIVE_DIRECTIONS: RelativeIntervalDirection[] = ["past", "current"];
const SPECIFIC_TYPE_VALUE = "__date_filter_specific__" as const;
@@ -201,22 +199,26 @@ function ConversationDateFilter({
);
}
+type FilterOption = { value: string; label: string };
+
+type SelectFilter = {
+ /** `null` when the filter is off. */
+ value: string | null;
+ options: FilterOption[];
+ onChange: (val: string | null) => void;
+};
+
+type GroupFilter = SelectFilter & {
+ noFilterValue: string;
+};
+
type ConversationFiltersProps = {
date: string | null;
onDateChange: (val: string) => void;
- user: string | null;
- onUserChange: (val: string | null) => void;
- group: string | null;
- onGroupChange: (val: string | null) => void;
- groupNoFilterValue: string;
- tenant: string | null;
- onTenantChange: (val: string | null) => void;
- userOptions: { value: string; label: string }[];
- groupOptions: { value: string; label: string }[];
- tenantOptions: { value: string; label: string }[];
- hasTenants: boolean;
- /** Hides the user select for pages where filtering by user isn't a meaningful concept. */
- hasUsers?: boolean;
+ // Each filter shows only when it's passed.
+ userFilter?: SelectFilter;
+ groupFilter?: GroupFilter;
+ tenantFilter?: SelectFilter;
/** Rendered right after the Group select, before User/Date — for a caller-specific filter that
* belongs grouped with Group rather than after the rest of this shared bar. */
extraFilter?: ReactNode;
@@ -225,51 +227,44 @@ type ConversationFiltersProps = {
export function ConversationFilters({
date,
onDateChange,
- user,
- onUserChange,
- group,
- onGroupChange,
- groupNoFilterValue,
- tenant,
- onTenantChange,
- userOptions,
- groupOptions,
- tenantOptions,
- hasTenants,
- hasUsers = true,
+ userFilter,
+ groupFilter,
+ tenantFilter,
extraFilter,
}: ConversationFiltersProps) {
return (
<Flex gap="sm" wrap="wrap" align="center">
- {hasTenants && (
+ {tenantFilter && (
<Select
- data={[{ value: "", label: t`All tenants` }, ...tenantOptions]}
- value={tenant ?? ""}
- onChange={(val) => onTenantChange(val === "" ? null : val)}
+ data={[{ value: "", label: t`All tenants` }, ...tenantFilter.options]}
+ value={tenantFilter.value ?? ""}
+ onChange={(val) => tenantFilter.onChange(val === "" ? null : val)}
searchable
w={FILTER_WIDTH}
bdrs="xs"
data-testid="conversation-filters-tenant-select"
/>
)}
- <Select
- placeholder={t`Group`}
- data={groupOptions}
- value={group ?? groupNoFilterValue}
- onChange={(val) =>
- onGroupChange(val === groupNoFilterValue ? null : val)
- }
- searchable
- w={FILTER_WIDTH}
- bdrs="xs"
- data-testid="conversation-filters-group-select"
- />
+ {groupFilter && (
+ <Select
+ placeholder={t`Group`}
+ data={groupFilter.options}
+ value={groupFilter.value ?? groupFilter.noFilterValue}
+ onChange={(val) =>
+ groupFilter.onChange(val === groupFilter.noFilterValue ? null : val)
+ }
+ searchable
+ w={FILTER_WIDTH}
+ bdrs="xs"
+ data-testid="conversation-filters-group-select"
+ />
+ )}
{extraFilter}
- {hasUsers && (
+ {userFilter && (
<Select
- data={[{ value: "", label: t`All users` }, ...userOptions]}
- value={user ?? ""}
- onChange={(val) => onUserChange(val === "" ? null : val)}
+ data={[{ value: "", label: t`All users` }, ...userFilter.options]}
+ value={userFilter.value ?? ""}
+ onChange={(val) => userFilter.onChange(val === "" ? null : val)}
searchable
w={FILTER_WIDTH}
bdrs="xs"
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/ConversationFilters.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/ConversationFilters.unit.spec.tsx
index 3df73fd86c9..9267eb444ed 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/ConversationFilters.unit.spec.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/ConversationFilters.unit.spec.tsx
@@ -1,4 +1,5 @@
import userEvent from "@testing-library/user-event";
+import type { ComponentProps } from "react";
import { setupEnterprisePlugins } from "__support__/enterprise";
import { mockSettings } from "__support__/settings";
@@ -7,29 +8,22 @@ import { renderWithProviders, screen, within } from "__support__/ui";
import { ConversationFilters } from "./ConversationFilters";
-function setup({
- retentionDays,
- date = null,
-}: {
+type SetupOpts = {
retentionDays: number | null;
date?: string | null;
-}) {
+ filters?: Omit<
+ ComponentProps<typeof ConversationFilters>,
+ "date" | "onDateChange"
+ >;
+};
+
+function setup({ retentionDays, date = null, filters }: SetupOpts) {
setupEnterprisePlugins();
renderWithProviders(
<ConversationFilters
date={date}
onDateChange={() => undefined}
- user={null}
- onUserChange={() => undefined}
- group={null}
- onGroupChange={() => undefined}
- groupNoFilterValue="all"
- tenant={null}
- onTenantChange={() => undefined}
- userOptions={[]}
- groupOptions={[]}
- tenantOptions={[]}
- hasTenants={false}
+ {...filters}
/>,
{
storeInitialState: createMockState({
@@ -173,3 +167,29 @@ describe("ConversationFilters date dropdown", () => {
expect(screen.getByLabelText("End date")).toHaveValue("March 15, 2026");
});
});
+
+describe("ConversationFilters selects", () => {
+ it("shows only the filters a page passes", () => {
+ setup({
+ retentionDays: null,
+ filters: {
+ groupFilter: {
+ value: null,
+ options: [{ value: "1", label: "All groups" }],
+ noFilterValue: "1",
+ onChange: () => undefined,
+ },
+ },
+ });
+
+ expect(screen.getByTestId("conversation-filters-group-select")).toHaveValue(
+ "All groups",
+ );
+ expect(
+ screen.queryByTestId("conversation-filters-user-select"),
+ ).not.toBeInTheDocument();
+ expect(
+ screen.queryByTestId("conversation-filters-tenant-select"),
+ ).not.toBeInTheDocument();
+ });
+});
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/useFilterOptions.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/useFilterOptions.ts
index bf48668c844..b24f7828dc7 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/useFilterOptions.ts
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/useFilterOptions.ts
@@ -62,20 +62,28 @@ function sortGroupsTenantsDisabled(
return [...defaultGroup, ...rest];
}
-export function useFilterOptions({
- date,
- user,
- group,
- tenant,
-}: FilterUrlState) {
+type UseFilterOptionsOpts = {
+ /** Off for a page without the group and tenant filters, so their options aren't loaded. */
+ hasGroupAndTenantFilters?: boolean;
+};
+
+export function useFilterOptions(
+ { date, user, group, tenant }: FilterUrlState,
+ { hasGroupAndTenantFilters = true }: UseFilterOptionsOpts = {},
+) {
const useTenantsSetting = useSetting("use-tenants");
const tenantsFeatureEnabled =
!!hasPremiumFeature("tenants") && !!useTenantsSetting;
const { data: usersData, isLoading: isLoadingUsers } = useListUsersQuery({});
const { data: groupsData, isLoading: isLoadingGroups } =
- useListPermissionsGroupsQuery(undefined);
+ useListPermissionsGroupsQuery(undefined, {
+ skip: !hasGroupAndTenantFilters,
+ });
const { data: tenantsData, isLoading: isLoadingTenants } =
- useListTenantsQuery({ status: "active" }, { skip: !tenantsFeatureEnabled });
+ useListTenantsQuery(
+ { status: "active" },
+ { skip: !tenantsFeatureEnabled || !hasGroupAndTenantFilters },
+ );
const userOptions = useMemo(
() =>
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/useFilterOptions.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/useFilterOptions.unit.spec.ts
index abd7d9b526e..f3ee328b96f 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/useFilterOptions.unit.spec.ts
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationFilters/useFilterOptions.unit.spec.ts
@@ -18,9 +18,11 @@ import { useFilterOptions } from "./useFilterOptions";
const setup = ({
tenantsEnabled,
groups,
+ hasGroupAndTenantFilters,
}: {
tenantsEnabled: boolean;
groups: Partial<Group>[];
+ hasGroupAndTenantFilters?: boolean;
}) => {
setupUsersEndpoints([]);
setupGroupsEndpoint(groups.map(createMockGroup));
@@ -28,7 +30,10 @@ const setup = ({
return renderHookWithProviders(
() =>
- useFilterOptions({ date: null, user: null, group: null, tenant: null }),
+ useFilterOptions(
+ { date: null, user: null, group: null, tenant: null },
+ { hasGroupAndTenantFilters },
+ ),
{
storeInitialState: createMockState({
settings: mockSettings({
@@ -89,4 +94,21 @@ describe("useFilterOptions", () => {
expect(labels).toContain("All groups");
expect(labels).not.toContain("All Users");
});
+
+ it("loads neither groups nor tenants for a page without those filters", async () => {
+ const { result } = setup({
+ tenantsEnabled: true,
+ groups: [{ id: 1, name: "All Users" }],
+ hasGroupAndTenantFilters: false,
+ });
+
+ await waitFor(() => {
+ expect(result.current.isLoading).toBe(false);
+ });
+ expect(fetchMock.callHistory.called("path:/api/permissions/group")).toBe(
+ false,
+ );
+ expect(fetchMock.callHistory.called("path:/api/ee/tenant")).toBe(false);
+ expect(result.current.hasTenants).toBe(false);
+ });
});
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/ConversationStatsPage.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/ConversationStatsPage.tsx
index 05146c73e7a..eb14396f06d 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/ConversationStatsPage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/ConversationStatsPage.tsx
@@ -358,17 +358,26 @@ function UsageStats({ metric }: UsageStatsProps) {
<ConversationFilters
date={date}
onDateChange={(val) => patchUrlState({ date: val })}
- user={user}
- onUserChange={(val) => patchUrlState({ user: val })}
- group={group}
- onGroupChange={(val) => patchUrlState({ group: val })}
- groupNoFilterValue={groupNoFilterValue}
- tenant={tenant}
- onTenantChange={(val) => patchUrlState({ tenant: val })}
- userOptions={userOptions}
- groupOptions={groupOptions}
- tenantOptions={tenantOptions}
- hasTenants={hasTenants}
+ userFilter={{
+ value: user,
+ options: userOptions,
+ onChange: (val) => patchUrlState({ user: val }),
+ }}
+ groupFilter={{
+ value: group,
+ options: groupOptions,
+ noFilterValue: groupNoFilterValue,
+ onChange: (val) => patchUrlState({ group: val }),
+ }}
+ tenantFilter={
+ hasTenants
+ ? {
+ value: tenant,
+ options: tenantOptions,
+ onChange: (val) => patchUrlState({ tenant: val }),
+ }
+ : undefined
+ }
/>
<Stack gap="xl">
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/ConversationsByDayChart.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/ConversationsByDayChart.tsx
index 546215cffc8..c0bfa49f4bf 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/ConversationsByDayChart.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/ConversationsByDayChart.tsx
@@ -4,6 +4,7 @@ import { t } from "ttag";
import { dayjs } from "metabase/dayjs";
import type { DateFilterValue } from "metabase/querying/common/types";
import { Skeleton, useMantineTheme } from "metabase/ui";
+import { findColumn } from "metabase-enterprise/monitor/query-utils";
import type { Query } from "metabase-lib";
import * as Lib from "metabase-lib";
@@ -16,7 +17,6 @@ import {
type UsageStatsMetric,
applyUsageStatsAggregation,
buildFilteredQuery,
- findColumn,
getMetricSeriesSettings,
} from "./query-utils";
import {
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils.ts
index ffcb80c9dc7..24673b3dc58 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils.ts
@@ -2,11 +2,16 @@ import { P, match } from "ts-pattern";
import { t } from "ttag";
import type { DateFilterValue } from "metabase/querying/common/types";
-import { getDateFilterClause } from "metabase/querying/filters/utils/dates";
import type { ColorName } from "metabase/ui/colors/types";
+import {
+ applyDateFilter,
+ applyIdFilter,
+ breakoutByColumn,
+ findColumn,
+ joinGroupMembers,
+} from "metabase-enterprise/monitor/query-utils";
import type {
CardMetadata,
- ColumnMetadata,
MetadataProvider,
Query,
TableMetadata,
@@ -84,96 +89,6 @@ export function getMetricSeriesSettings(
});
}
-export function findColumn(
- query: Query,
- name: string,
- columnsFn: (q: Query, stageIndex: number) => ColumnMetadata[],
-): ColumnMetadata | undefined {
- const columns = columnsFn(query, 0);
- const lowerName = name.toLowerCase();
- return columns.find((col) => {
- const info = Lib.displayInfo(query, 0, col);
- return info.name?.toLowerCase() === lowerName;
- });
-}
-
-export function applyDateFilter(
- query: Query,
- dateFilter: DateFilterValue,
- columnName = "created_at",
-): Query {
- const dateCol = findColumn(query, columnName, Lib.filterableColumns);
- if (!dateCol) {
- return query;
- }
-
- const clause = getDateFilterClause(dateCol, dateFilter);
- return Lib.filter(query, 0, clause);
-}
-
-export function applyIdFilter(
- query: Query,
- columnName: string,
- id: number | undefined,
-): Query {
- if (id == null) {
- return query;
- }
- const column = findColumn(query, columnName, Lib.filterableColumns);
- if (!column) {
- return query;
- }
- return Lib.filter(
- query,
- 0,
- Lib.numberFilterClause({ operator: "=", column, values: [id] }),
- );
-}
-
-function findJoinableColumn(
- columns: ColumnMetadata[],
- query: Query,
- name: string,
-): ColumnMetadata | undefined {
- const lower = name.toLowerCase();
- return columns.find((col) => {
- const info = Lib.displayInfo(query, 0, col);
- return info.name?.toLowerCase() === lower;
- });
-}
-
-export function joinGroupMembers(
- query: Query,
- groupMembersTable: TableMetadata | CardMetadata,
- sourceUserIdColumn = "user_id",
-): Query {
- const lhsColumns = Lib.joinConditionLHSColumns(query, 0, groupMembersTable);
- const lhsUserId = findJoinableColumn(lhsColumns, query, sourceUserIdColumn);
- const rhsColumns = Lib.joinConditionRHSColumns(query, 0, groupMembersTable);
- const rhsUserId = findJoinableColumn(rhsColumns, query, "user_id");
- if (!lhsUserId || !rhsUserId) {
- return query;
- }
-
- const innerJoin = Lib.availableJoinStrategies(query, 0).find((strategy) => {
- const info = Lib.displayInfo(query, 0, strategy);
- return info.shortName === "inner-join";
- });
- if (!innerJoin) {
- return query;
- }
-
- return Lib.join(
- query,
- 0,
- Lib.joinClause(
- groupMembersTable,
- [Lib.joinConditionClause("=", lhsUserId, rhsUserId)],
- innerJoin,
- ),
- );
-}
-
export function addSumAggregation(query: Query, columnName: string): Query {
const operators = Lib.availableAggregationOperators(query, 0);
const sumOp = operators.find((op) => {
@@ -280,11 +195,6 @@ export function buildSourceBreakoutQuery({
return q;
}
-export function breakoutByColumn(query: Query, columnName: string): Query {
- const col = findColumn(query, columnName, Lib.breakoutableColumns);
- return col ? Lib.breakout(query, 0, col) : query;
-}
-
type BreakoutQueryOpts = StatsFilters & {
provider: MetadataProvider;
table: TableMetadata | CardMetadata;
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils.unit.spec.ts
index 0aa7c44d2fb..9090e73d734 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils.unit.spec.ts
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils.unit.spec.ts
@@ -3,11 +3,7 @@ import * as Lib from "metabase-lib";
import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
import { isSingleDayFilter } from "./ConversationsByDayChart";
-import {
- applyIdFilter,
- excludeAllUsersGroup,
- getMetricSeriesSettings,
-} from "./query-utils";
+import { excludeAllUsersGroup, getMetricSeriesSettings } from "./query-utils";
describe("getMetricSeriesSettings", () => {
const getColor = (name: string) => `#${name}`;
@@ -165,33 +161,6 @@ describe("isSingleDayFilter", () => {
});
});
-describe("applyIdFilter", () => {
- const baseQuery = () =>
- Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
-
- it("is a no-op when id is undefined", () => {
- const q = baseQuery();
- const result = applyIdFilter(q, "user_id", undefined);
- expect(Lib.filters(result, 0)).toHaveLength(0);
- });
-
- it("adds an equality filter on the named column when present (Orders.USER_ID matches case-insensitively)", () => {
- const q = baseQuery();
- const result = applyIdFilter(q, "user_id", 42);
- const [clause, ...rest] = Lib.filters(result, 0);
- expect(rest).toHaveLength(0);
- const parts = Lib.numberFilterParts(result, 0, clause);
- expect(parts?.operator).toBe("=");
- expect(parts?.values).toEqual([42]);
- });
-
- it("is a no-op when the column cannot be found on the query", () => {
- const q = baseQuery();
- const result = applyIdFilter(q, "column_that_does_not_exist", 42);
- expect(Lib.filters(result, 0)).toHaveLength(0);
- });
-});
-
describe("excludeAllUsersGroup", () => {
const baseQuery = () =>
Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationsPage/ConversationsPage.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationsPage/ConversationsPage.tsx
index 5e492a1bd26..7015f189bdf 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationsPage/ConversationsPage.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationsPage/ConversationsPage.tsx
@@ -70,17 +70,26 @@ export function ConversationsPage() {
<ConversationFilters
date={date}
onDateChange={(val) => patchUrlState({ date: val, page: 0 })}
- user={user}
- onUserChange={(val) => patchUrlState({ user: val, page: 0 })}
- group={group}
- onGroupChange={(val) => patchUrlState({ group: val, page: 0 })}
- groupNoFilterValue={groupNoFilterValue}
- tenant={tenant}
- onTenantChange={(val) => patchUrlState({ tenant: val, page: 0 })}
- userOptions={userOptions}
- groupOptions={groupOptions}
- tenantOptions={tenantOptions}
- hasTenants={hasTenants}
+ userFilter={{
+ value: user,
+ options: userOptions,
+ onChange: (val) => patchUrlState({ user: val, page: 0 }),
+ }}
+ groupFilter={{
+ value: group,
+ options: groupOptions,
+ noFilterValue: groupNoFilterValue,
+ onChange: (val) => patchUrlState({ group: val, page: 0 }),
+ }}
+ tenantFilter={
+ hasTenants
+ ? {
+ value: tenant,
+ options: tenantOptions,
+ onChange: (val) => patchUrlState({ tenant: val, page: 0 }),
+ }
+ : undefined
+ }
/>
<ConversationsTable
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/routes.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/routes.tsx
index 009c4066b9b..0702e590263 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/routes.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/routes.tsx
@@ -1,3 +1,4 @@
+import { PLUGIN_DATA_APPS } from "metabase/plugins";
import { Route, redirect, registerPagePrefetch } from "metabase/router";
import * as Urls from "metabase/urls";
@@ -8,7 +9,7 @@ import {
/**
* The AI auditing pages, in one chunk. Every loader names it, so moving between
- * usage, conversations, MCP and CLI does not cost a fetch each time.
+ * usage, conversations, MCP, CLI and data apps does not cost a fetch each time.
*
* The plugin registry assigns these routes on every page load, so whatever they
* name is in the initial bundle. The pages carry the charting and data grid
@@ -78,6 +79,13 @@ const cliCallsPage = () =>
Component: CliCallsPage,
}));
+const dataAppsAnalyticsPage = () =>
+ import(
+ /* webpackChunkName: "ai-auditing" */ "./data-apps-analytics/components/DataAppsAnalyticsPage"
+ ).then(({ DataAppsAnalyticsPage }) => ({
+ Component: DataAppsAnalyticsPage,
+ }));
+
/**
* Hovering a Monitor sidebar link starts the fetch, so the chunk is usually in
* hand by the time the click lands. These pages share a chunk, so the first
@@ -100,6 +108,7 @@ export function registerAiAuditingPagePrefetch(): void {
);
registerPagePrefetch(Urls.monitorAiAuditingMcp(), mcpAnalyticsSectionLayout);
registerPagePrefetch(Urls.monitorAiAuditingCli(), cliAnalyticsSectionLayout);
+ registerDataAppsAnalyticsPagePrefetch();
}
/** The section as an instance without the license mounts it: usage upsells. */
@@ -110,6 +119,14 @@ export function registerAiAuditingUpsellPagePrefetch(): void {
);
registerPagePrefetch(Urls.monitorAiAuditingMcp(), mcpAnalyticsSectionLayout);
registerPagePrefetch(Urls.monitorAiAuditingCli(), cliAnalyticsSectionLayout);
+ registerDataAppsAnalyticsPagePrefetch();
+}
+
+// Unconditional: the audit app plugin registers these before the data apps plugin sets
+// `PLUGIN_DATA_APPS.isEnabled`, and the page shares the section's chunk, so prefetching it
+// costs nothing on an instance that can't open it.
+function registerDataAppsAnalyticsPagePrefetch() {
+ registerPagePrefetch(Urls.monitorAiAuditingDataApps(), dataAppsAnalyticsPage);
}
function getMcpAnalyticsRoutes() {
@@ -138,6 +155,13 @@ function getCliAnalyticsRoutes() {
);
}
+function getDataAppsAnalyticsRoutes() {
+ if (!PLUGIN_DATA_APPS.isEnabled) {
+ return null;
+ }
+ return <Route path="data-apps" lazy={dataAppsAnalyticsPage} />;
+}
+
export function getAiAuditingRoutes() {
return (
<>
@@ -152,6 +176,7 @@ export function getAiAuditingRoutes() {
</Route>
{getMcpAnalyticsRoutes()}
{getCliAnalyticsRoutes()}
+ {getDataAppsAnalyticsRoutes()}
</>
);
}
@@ -163,6 +188,7 @@ export function getAiAuditingUpsellRoutes() {
<Route path="usage/*" lazy={metabotAnalyticsUpsellPage} />
{getMcpAnalyticsRoutes()}
{getCliAnalyticsRoutes()}
+ {getDataAppsAnalyticsRoutes()}
</>
);
}
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/routes.unit.spec.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/routes.unit.spec.tsx
index ebe14272d23..fe6f9dee708 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/routes.unit.spec.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/ai-auditing/routes.unit.spec.tsx
@@ -1,11 +1,21 @@
import { mockSettings } from "__support__/settings";
import { createMockState } from "__support__/state";
import { renderWithProviders, screen, waitFor } from "__support__/ui";
+import { PLUGIN_DATA_APPS, reinitialize } from "metabase/plugins";
import type * as Router from "metabase/router";
-import { Route } from "metabase/router";
+import { Route, registerPagePrefetch } from "metabase/router";
import * as Urls from "metabase/urls";
-import { getAiAuditingRoutes, getAiAuditingUpsellRoutes } from "./routes";
+import {
+ getAiAuditingRoutes,
+ getAiAuditingUpsellRoutes,
+ registerAiAuditingPagePrefetch,
+} from "./routes";
+
+jest.mock("metabase/router", () => ({
+ ...jest.requireActual<typeof Router>("metabase/router"),
+ registerPagePrefetch: jest.fn(),
+}));
jest.mock("./metabot-analytics/components/ConversationStatsPage", () => ({
ConversationStatsPage: () => <div>Usage stats page</div>,
@@ -56,6 +66,9 @@ jest.mock("./cli-analytics/components/CliUsagePage", () => ({
jest.mock("./cli-analytics/components/CliCallsPage", () => ({
CliCallsPage: () => <div>CLI calls page</div>,
}));
+jest.mock("./data-apps-analytics/components/DataAppsAnalyticsPage", () => ({
+ DataAppsAnalyticsPage: () => <div>Data app analytics page</div>,
+}));
type SetupOpts = {
route: string;
@@ -63,6 +76,7 @@ type SetupOpts = {
aiFeaturesEnabled?: boolean;
isConfigured?: boolean;
mcpEnabled?: boolean;
+ hasDataApps?: boolean;
};
function setup({
@@ -71,26 +85,34 @@ function setup({
aiFeaturesEnabled = true,
isConfigured = true,
mcpEnabled = true,
+ hasDataApps = false,
}: SetupOpts) {
+ // The routes read it as they're built, so set it first.
+ PLUGIN_DATA_APPS.isEnabled = hasDataApps;
+ const settings = mockSettings({
+ "ai-features-enabled?": aiFeaturesEnabled,
+ "llm-metabot-configured?": isConfigured,
+ "mcp-enabled?": mcpEnabled,
+ });
+
return renderWithProviders(
<Route path="/monitor/ai-auditing">
{upsell ? getAiAuditingUpsellRoutes() : getAiAuditingRoutes()}
+ <Route path="*" element={<div>Not found</div>} />
</Route>,
{
initialRoute: route,
withRouter: true,
- storeInitialState: createMockState({
- settings: mockSettings({
- "ai-features-enabled?": aiFeaturesEnabled,
- "llm-metabot-configured?": isConfigured,
- "mcp-enabled?": mcpEnabled,
- }),
- }),
+ storeInitialState: createMockState({ settings }),
},
);
}
describe("AI Auditing routes", () => {
+ afterEach(() => {
+ reinitialize();
+ });
+
it.each([false, true])(
"redirects the section root to Usage stats and preserves the query when upsell is %s",
async (upsell) => {
@@ -253,6 +275,46 @@ describe("AI Auditing routes", () => {
},
);
+ describe.each([false, true])("Data app analytics (upsell %s)", (upsell) => {
+ it("renders the page with the data-apps feature, whatever the AI settings", async () => {
+ setup({
+ route: Urls.monitorAiAuditingDataApps(),
+ upsell,
+ hasDataApps: true,
+ aiFeaturesEnabled: false,
+ isConfigured: false,
+ });
+
+ expect(
+ await screen.findByText("Data app analytics page"),
+ ).toBeInTheDocument();
+ });
+
+ it("does not mount the section without the data-apps feature", async () => {
+ setup({
+ route: Urls.monitorAiAuditingDataApps(),
+ upsell,
+ hasDataApps: false,
+ });
+
+ expect(await screen.findByText("Not found")).toBeInTheDocument();
+ expect(
+ screen.queryByText("Data app analytics page"),
+ ).not.toBeInTheDocument();
+ });
+ });
+
+ it("registers the Data app analytics prefetch before the data apps plugin sets its flag", () => {
+ PLUGIN_DATA_APPS.isEnabled = false;
+
+ registerAiAuditingPagePrefetch();
+
+ expect(jest.mocked(registerPagePrefetch)).toHaveBeenCalledWith(
+ Urls.monitorAiAuditingDataApps(),
+ expect.any(Function),
+ );
+ });
+
it("applies MCP availability to the upsell route set", async () => {
setup({
route: "/monitor/ai-auditing/mcp",
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/components/ApiKeyFilterSelect.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/components/ApiKeyFilterSelect.tsx
index daca0cc826a..a98358283fe 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/components/ApiKeyFilterSelect.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/components/ApiKeyFilterSelect.tsx
@@ -2,12 +2,10 @@ import { useMemo } from "react";
import { t } from "ttag";
import { useListApiKeysQuery } from "metabase/admin/settings/api/api-key";
+import { FILTER_WIDTH } from "metabase/monitor/constants";
import { Select } from "metabase/ui";
import { apiKeyMatchesScope } from "metabase-enterprise/monitor/api-key-usage/query-utils";
-// Matches the width of the shared ConversationFilters selects it sits alongside.
-const FILTER_WIDTH = 205;
-
type Props = {
value: string | null;
onChange: (value: string | null) => void;
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/components/ApiKeyUsageSectionLayout.tsx b/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/components/ApiKeyUsageSectionLayout.tsx
index ee21b2f4cb9..5d112e6f99c 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/components/ApiKeyUsageSectionLayout.tsx
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/components/ApiKeyUsageSectionLayout.tsx
@@ -75,14 +75,8 @@ export function ApiKeyUsageSectionLayout() {
{ patchUrlState },
] = useUrlState(location, apiKeyUsageUrlStateConfig);
- const {
- dateFilter,
- userId,
- groupId,
- groupNoFilterValue,
- userOptions,
- groupOptions,
- } = useFilterOptions({ date, user, group, tenant });
+ const { dateFilter, userId, groupId, groupNoFilterValue, groupOptions } =
+ useFilterOptions({ date, user, group, tenant });
const { data: apiKeys } = useListApiKeysQuery();
const selectedApiKey = useMemo(
@@ -190,34 +184,23 @@ export function ApiKeyUsageSectionLayout() {
<ApiKeyUsageFilterBar
date={date}
onDateChange={(val) => patchUrlState({ date: val, page: 0 })}
- user={user}
- onUserChange={(val) => patchUrlState({ user: val, page: 0 })}
- userOptions={userOptions}
- group={group}
- onGroupChange={(val) =>
- patchUrlState({
- group: val,
- // Like picking a new State: a key that isn't in the new group is cleared.
- ...(isKeyOutsideGroup(
- selectedApiKey,
- val == null ? null : Number(val),
- )
- ? { api_key: null }
- : {}),
- page: 0,
- })
- }
- groupOptions={groupOptions}
- groupNoFilterValue={groupNoFilterValue}
- // Tenants aren't a meaningful concept for API-key usage — see EMB-2391, which will make
- // this shared filter bar's tenant support properly optional instead of hardcoded off here.
- tenant={null}
- onTenantChange={() => {}}
- tenantOptions={[]}
- hasTenants={false}
- // The API key filter (below) is the primary way to scope this page; a separate user
- // filter is redundant now that "Created by" is just a column.
- hasUsers={false}
+ groupFilter={{
+ value: group,
+ options: groupOptions,
+ noFilterValue: groupNoFilterValue,
+ onChange: (val) =>
+ patchUrlState({
+ group: val,
+ // Like picking a new State: a key that isn't in the new group is cleared.
+ ...(isKeyOutsideGroup(
+ selectedApiKey,
+ val == null ? null : Number(val),
+ )
+ ? { api_key: null }
+ : {}),
+ page: 0,
+ }),
+ }}
extraFilter={
<ApiKeyFilterSelect
value={keyOutsideGroup ? null : api_key}
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/query-utils.ts b/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/query-utils.ts
index d265e386382..9aa2cb02b15 100644
--- a/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/query-utils.ts
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/api-key-usage/query-utils.ts
@@ -5,7 +5,7 @@ import {
breakoutByColumn,
findColumn,
joinGroupMembers,
-} from "metabase-enterprise/monitor/ai-auditing/metabot-analytics/components/ConversationStatsPage/query-utils";
+} from "metabase-enterprise/monitor/query-utils";
import type {
CardMetadata,
ColumnMetadata,
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/query-utils.ts b/enterprise/frontend/src/metabase-enterprise/monitor/query-utils.ts
new file mode 100644
index 00000000000..780565169a7
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/query-utils.ts
@@ -0,0 +1,101 @@
+import type { DateFilterValue } from "metabase/querying/common/types";
+import { getDateFilterClause } from "metabase/querying/filters/utils/dates";
+import * as Lib from "metabase-lib";
+
+export function findColumn(
+ query: Lib.Query,
+ name: string,
+ columnsFn: (q: Lib.Query, stageIndex: number) => Lib.ColumnMetadata[],
+): Lib.ColumnMetadata | undefined {
+ const columns = columnsFn(query, 0);
+ const lowerName = name.toLowerCase();
+ return columns.find((col) => {
+ const info = Lib.displayInfo(query, 0, col);
+ return info.name?.toLowerCase() === lowerName;
+ });
+}
+
+export function applyDateFilter(
+ query: Lib.Query,
+ dateFilter: DateFilterValue,
+ columnName = "created_at",
+): Lib.Query {
+ const dateCol = findColumn(query, columnName, Lib.filterableColumns);
+ if (!dateCol) {
+ return query;
+ }
+
+ const clause = getDateFilterClause(dateCol, dateFilter);
+ return Lib.filter(query, 0, clause);
+}
+
+export function applyIdFilter(
+ query: Lib.Query,
+ columnName: string,
+ id: number | undefined,
+): Lib.Query {
+ if (id === undefined) {
+ return query;
+ }
+ const column = findColumn(query, columnName, Lib.filterableColumns);
+ if (!column) {
+ return query;
+ }
+ return Lib.filter(
+ query,
+ 0,
+ Lib.numberFilterClause({ operator: "=", column, values: [id] }),
+ );
+}
+
+export function breakoutByColumn(
+ query: Lib.Query,
+ columnName: string,
+): Lib.Query {
+ const col = findColumn(query, columnName, Lib.breakoutableColumns);
+ return col ? Lib.breakout(query, 0, col) : query;
+}
+
+function findJoinableColumn(
+ columns: Lib.ColumnMetadata[],
+ query: Lib.Query,
+ name: string,
+): Lib.ColumnMetadata | undefined {
+ const lower = name.toLowerCase();
+ return columns.find((col) => {
+ const info = Lib.displayInfo(query, 0, col);
+ return info.name?.toLowerCase() === lower;
+ });
+}
+
+export function joinGroupMembers(
+ query: Lib.Query,
+ groupMembersTable: Lib.TableMetadata | Lib.CardMetadata,
+ sourceUserIdColumn = "user_id",
+): Lib.Query {
+ const lhsColumns = Lib.joinConditionLHSColumns(query, 0, groupMembersTable);
+ const lhsUserId = findJoinableColumn(lhsColumns, query, sourceUserIdColumn);
+ const rhsColumns = Lib.joinConditionRHSColumns(query, 0, groupMembersTable);
+ const rhsUserId = findJoinableColumn(rhsColumns, query, "user_id");
+ if (!lhsUserId || !rhsUserId) {
+ return query;
+ }
+
+ const innerJoin = Lib.availableJoinStrategies(query, 0).find((strategy) => {
+ const info = Lib.displayInfo(query, 0, strategy);
+ return info.shortName === "inner-join";
+ });
+ if (!innerJoin) {
+ return query;
+ }
+
+ return Lib.join(
+ query,
+ 0,
+ Lib.joinClause(
+ groupMembersTable,
+ [Lib.joinConditionClause("=", lhsUserId, rhsUserId)],
+ innerJoin,
+ ),
+ );
+}
diff --git a/enterprise/frontend/src/metabase-enterprise/monitor/query-utils.unit.spec.ts b/enterprise/frontend/src/metabase-enterprise/monitor/query-utils.unit.spec.ts
new file mode 100644
index 00000000000..7d909c0f924
--- /dev/null
+++ b/enterprise/frontend/src/metabase-enterprise/monitor/query-utils.unit.spec.ts
@@ -0,0 +1,31 @@
+import * as Lib from "metabase-lib";
+import { DEFAULT_TEST_QUERY, SAMPLE_PROVIDER } from "metabase-lib/test-helpers";
+
+import { applyIdFilter } from "./query-utils";
+
+describe("applyIdFilter", () => {
+ const baseQuery = () =>
+ Lib.createTestQuery(SAMPLE_PROVIDER, DEFAULT_TEST_QUERY);
+
+ it("is a no-op when id is undefined", () => {
+ const q = baseQuery();
+ const result = applyIdFilter(q, "user_id", undefined);
+ expect(Lib.filters(result, 0)).toHaveLength(0);
+ });
+
+ it("adds an equality filter on the named column when present (Orders.USER_ID matches case-insensitively)", () => {
+ const q = baseQuery();
+ const result = applyIdFilter(q, "user_id", 42);
+ const [clause, ...rest] = Lib.filters(result, 0);
+ expect(rest).toHaveLength(0);
+ const parts = Lib.numberFilterParts(result, 0, clause);
+ expect(parts?.operator).toBe("=");
+ expect(parts?.values).toEqual([42]);
+ });
+
+ it("is a no-op when the column cannot be found on the query", () => {
+ const q = baseQuery();
+ const result = applyIdFilter(q, "column_that_does_not_exist", 42);
+ expect(Lib.filters(result, 0)).toHaveLength(0);
+ });
+});
diff --git a/frontend/src/metabase/common/monitor/analytics.ts b/frontend/src/metabase/common/monitor/analytics.ts
index c6cc9a49def..239819692b8 100644
--- a/frontend/src/metabase/common/monitor/analytics.ts
+++ b/frontend/src/metabase/common/monitor/analytics.ts
@@ -14,6 +14,7 @@ export type MonitorSection =
| "ai-auditing-conversations"
| "ai-auditing-mcp"
| "ai-auditing-cli"
+ | "ai-auditing-data-apps"
| "api-key-usage";
export const trackMonitorOpened = () => {
diff --git a/frontend/src/metabase/monitor/components/MonitorLayout/MonitorLayout.tsx b/frontend/src/metabase/monitor/components/MonitorLayout/MonitorLayout.tsx
index 4030109070c..d593468b28a 100644
--- a/frontend/src/metabase/monitor/components/MonitorLayout/MonitorLayout.tsx
+++ b/frontend/src/metabase/monitor/components/MonitorLayout/MonitorLayout.tsx
@@ -21,6 +21,7 @@ import {
AreaTab,
AreaTabGroup,
} from "metabase/nav/components/AreaLayout";
+import { PLUGIN_DATA_APPS } from "metabase/plugins";
import { useSelector } from "metabase/redux";
import { Outlet, useLocation } from "metabase/router";
import { FixedSizeIcon, Flex } from "metabase/ui";
@@ -66,6 +67,10 @@ function getActiveSection(pathname: string): ActiveSection {
P.string.startsWith(Urls.monitorAiAuditingCli()),
() => "ai-auditing-cli",
)
+ .with(
+ P.string.startsWith(Urls.monitorAiAuditingDataApps()),
+ () => "ai-auditing-data-apps",
+ )
.with(
P.string.startsWith(Urls.monitorAiAuditingConversations()),
() => "ai-auditing-conversations",
@@ -273,6 +278,18 @@ export function MonitorLayout() {
showLabel={isNavbarOpened}
onClick={() => trackMonitorSectionClicked("ai-auditing-cli")}
/>
+ {PLUGIN_DATA_APPS.isEnabled && (
+ <AreaTab
+ label={t`Data app analytics`}
+ icon="app"
+ to={Urls.monitorAiAuditingDataApps()}
+ isSelected={activeSection === "ai-auditing-data-apps"}
+ showLabel={isNavbarOpened}
+ onClick={() =>
+ trackMonitorSectionClicked("ai-auditing-data-apps")
+ }
+ />
+ )}
</AreaTabGroup>
)}
</>
diff --git a/frontend/src/metabase/monitor/components/MonitorLayout/MonitorLayout.unit.spec.tsx b/frontend/src/metabase/monitor/components/MonitorLayout/MonitorLayout.unit.spec.tsx
index 6edc3c5798c..5eaadbae755 100644
--- a/frontend/src/metabase/monitor/components/MonitorLayout/MonitorLayout.unit.spec.tsx
+++ b/frontend/src/metabase/monitor/components/MonitorLayout/MonitorLayout.unit.spec.tsx
@@ -9,6 +9,7 @@ import {
import { mockSettings } from "__support__/settings";
import { createMockState } from "__support__/state";
import { renderWithProviders, screen, waitFor, within } from "__support__/ui";
+import { PLUGIN_DATA_APPS, reinitialize } from "metabase/plugins";
import { Route } from "metabase/router";
import * as Urls from "metabase/urls";
import type { TokenFeatures } from "metabase-types/api";
@@ -35,6 +36,8 @@ interface SetupOpts {
aiFeaturesEnabled?: boolean;
isConfigured?: boolean;
mcpEnabled?: boolean;
+ /** What the data apps plugin sets on an instance with the data-apps feature. */
+ hasDataApps?: boolean;
initialRoute?: string;
user?: ReturnType<typeof createMockUser>;
children?: ReactNode;
@@ -83,10 +86,12 @@ const setup = ({
aiFeaturesEnabled = true,
isConfigured = true,
mcpEnabled = true,
+ hasDataApps = false,
initialRoute = "/monitor",
user = createMockUser({ is_superuser: true }),
children = <div data-testid="content">{"Content"}</div>,
}: SetupOpts = {}) => {
+ PLUGIN_DATA_APPS.isEnabled = hasDataApps;
const settings = mockSettings({
"token-features": createMockTokenFeatures(tokenFeatures),
"ai-features-enabled?": aiFeaturesEnabled,
@@ -130,6 +135,10 @@ const CONTENT_MANAGEMENT_GROUP = "Content management";
const LOGS_AND_ACTIVITY_GROUP = "Logs and activity";
describe("MonitorLayout", () => {
+ afterEach(() => {
+ reinitialize();
+ });
+
it("groups the sections under static headings with a link for each Monitor section", async () => {
setup();
@@ -662,6 +671,68 @@ describe("MonitorLayout", () => {
);
});
+ it("shows Data app analytics in AI Auditing when the data apps plugin is on", async () => {
+ setup({ tokenFeatures: { audit_app: true }, hasDataApps: true });
+
+ await waitFor(() => {
+ expect(screen.getByTestId("monitor-nav")).toBeInTheDocument();
+ });
+
+ const link = screen.getByRole("link", { name: "Data app analytics" });
+ expect(link).toHaveAttribute("href", Urls.monitorAiAuditingDataApps());
+ expect(
+ within(link).getByRole("img", { name: "app icon" }),
+ ).toBeInTheDocument();
+ });
+
+ it("hides Data app analytics while the data apps plugin is off, whatever the token says", async () => {
+ setup({
+ tokenFeatures: { audit_app: true, "data-apps": true },
+ hasDataApps: false,
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId("monitor-nav")).toBeInTheDocument();
+ });
+
+ expect(
+ screen.getByRole("link", { name: "CLI analytics" }),
+ ).toBeInTheDocument();
+ expect(
+ screen.queryByRole("link", { name: "Data app analytics" }),
+ ).not.toBeInTheDocument();
+ });
+
+ it("marks Data app analytics as the current page on its page", async () => {
+ setup({
+ initialRoute: Urls.monitorAiAuditingDataApps(),
+ tokenFeatures: { audit_app: true },
+ hasDataApps: true,
+ });
+
+ await waitFor(() => {
+ expect(screen.getByTestId("monitor-nav")).toBeInTheDocument();
+ });
+
+ const activeLink = screen.getByRole("link", { name: "Data app analytics" });
+ expect(screen.getAllByRole("link", { current: "page" })).toEqual([
+ activeLink,
+ ]);
+ });
+
+ it("tracks opening the Data app analytics section", async () => {
+ trackMonitorSectionClicked.mockClear();
+ setup({ tokenFeatures: { audit_app: true }, hasDataApps: true });
+
+ await userEvent.click(
+ await screen.findByRole("link", { name: "Data app analytics" }),
+ );
+
+ expect(trackMonitorSectionClicked).toHaveBeenCalledWith(
+ "ai-auditing-data-apps",
+ );
+ });
+
it("keeps MCP analytics available when the MCP server toggle is off", async () => {
setup({
tokenFeatures: { audit_app: true, ai_controls: true },
diff --git a/frontend/src/metabase/monitor/constants.ts b/frontend/src/metabase/monitor/constants.ts
index 45d559e788d..4d8de008bc9 100644
--- a/frontend/src/metabase/monitor/constants.ts
+++ b/frontend/src/metabase/monitor/constants.ts
@@ -1 +1,4 @@
export const PAGE_SIZE = 25;
+
+// width needed to show Previous 12 months option w/ clipping
+export const FILTER_WIDTH = 205;
diff --git a/frontend/src/metabase/monitor/routes.unit.spec.tsx b/frontend/src/metabase/monitor/routes.unit.spec.tsx
index 44754d599dd..fea68324fdc 100644
--- a/frontend/src/metabase/monitor/routes.unit.spec.tsx
+++ b/frontend/src/metabase/monitor/routes.unit.spec.tsx
@@ -7,7 +7,7 @@ import {
} from "__support__/server-mocks";
import { createMockSettingsState, createMockState } from "__support__/state";
import { renderWithProviders, screen, waitFor } from "__support__/ui";
-import { PLUGIN_AUDIT, reinitialize } from "metabase/plugins";
+import { PLUGIN_AUDIT, PLUGIN_DATA_APPS, reinitialize } from "metabase/plugins";
import { Route } from "metabase/router";
import * as Urls from "metabase/urls";
import type { TokenFeatures } from "metabase-types/api";
@@ -398,6 +398,22 @@ describe("monitor routes", () => {
).not.toBeInTheDocument();
});
+ it("blocks Data app analytics when the AI Auditing guard denies", async () => {
+ // The real AI Auditing routes, so it's their data-apps route the guard has to block.
+ setupEnterpriseOnlyPlugin("audit_app");
+ PLUGIN_DATA_APPS.isEnabled = true;
+
+ setup({
+ initialRoute: Urls.monitorAiAuditingDataApps(),
+ deny: ["CanAccessAiAuditing"],
+ });
+
+ expect(
+ await screen.findByTestId("unauthorized-marker"),
+ ).toBeInTheDocument();
+ expect(screen.queryByLabelText("error page")).not.toBeInTheDocument();
+ });
+
it("renders NotFound for unknown paths even when every section guard denies (catch-all sits outside the guards)", async () => {
setup({
initialRoute: "/monitor/does-not-exist",
diff --git a/frontend/src/metabase/urls/monitor.ts b/frontend/src/metabase/urls/monitor.ts
index f044448e556..6c6433101b1 100644
--- a/frontend/src/metabase/urls/monitor.ts
+++ b/frontend/src/metabase/urls/monitor.ts
@@ -143,6 +143,10 @@ export function monitorAiAuditingCliCalls() {
return `${monitorAiAuditingCli()}/calls`;
}
+export function monitorAiAuditingDataApps() {
+ return `${monitorAiAuditing()}/data-apps`;
+}
+
export function monitorApiKeyUsage() {
return `${ROOT_URL}/api-key-usage`;
}
diff --git a/src/metabase/analytics/core.clj b/src/metabase/analytics/core.clj
index 608a2d80aaa..96abe2d30da 100644
--- a/src/metabase/analytics/core.clj
+++ b/src/metabase/analytics/core.clj
@@ -39,6 +39,7 @@
[metabase.analytics.quartz
add-listeners-to-scheduler!]
[metabase.analytics.sdk
+ data-app-client?
embedding-context?
embedding-mw
extract-hostname
diff --git a/src/metabase/analytics/sdk.clj b/src/metabase/analytics/sdk.clj
index 9c951ca2853..2589c8b5e56 100644
--- a/src/metabase/analytics/sdk.clj
+++ b/src/metabase/analytics/sdk.clj
@@ -45,6 +45,17 @@
(defn get-client "Returns [[*client*]] dynamic var" [] *client*)
+(def ^:private data-app-client
+ "The [[*client*]] a published data app reports. It must match `EMBEDDING_SDK_CONFIG.metabaseClientRequestHeader` on
+ the FE: [[metabase.server.middleware.data-app-scope]] confines requests that carry it."
+ "data-app")
+
+(defn data-app-client?
+ "Whether `client`, by default the current [[*client*]], is a published data app. A data app's dev preview reports
+ another client."
+ ([] (data-app-client? (get-client)))
+ ([client] (= data-app-client client)))
+
#_{:clj-kondo/ignore [:metabase/discourage-dynamic-vars]}
(def ^:dynamic *client-identifier*
"Used to track the identifier of the concrete embedding client, e.g. the data-app name."
@@ -192,12 +203,12 @@
"embedding-iframe-static"
"embedding-public"
"embedding-simple"
- "data-app"})
+ data-app-client})
(defn- track-sdk-response
"Tabulates the number of responses by status code made by clients of the SDK."
[sdk-client {:keys [status]}]
- (case sdk-client
+ (condp = sdk-client
"embedding-sdk-react" (analytics/inc! :metabase-sdk/response {:status (str status)})
"embedding-iframe" (analytics/inc! :metabase-embedding-iframe/response {:status (str status)})
"embedding-iframe-full-app" (analytics/inc! :metabase-embedding-iframe-full-app/response {:status (str status)})
@@ -205,7 +216,7 @@
"embedding-public" (analytics/inc! :metabase-embedding-public/response {:status (str status)})
"embedding-simple" (analytics/inc! :metabase-embedding-simple/response {:status (str status)})
;; Known client, but a response-code counter tells us nothing actionable about data apps - so no metric.
- "data-app" nil
+ data-app-client nil
(log/info "Unknown client.")))
(defn embedding-context?
diff --git a/src/metabase/embedding/util.clj b/src/metabase/embedding/util.clj
index 8d80db62b43..dc2838f2c12 100644
--- a/src/metabase/embedding/util.clj
+++ b/src/metabase/embedding/util.clj
@@ -1,9 +1,10 @@
(ns metabase.embedding.util
- "Utility functions for common operations related to embedding.")
+ "Utility functions for common operations related to embedding."
+ (:require
+ [metabase.analytics.core :as analytics]))
(def ^:private embedding-sdk-client "embedding-sdk-react")
(def ^:private embedded-analytics-js-client "embedding-simple")
-(def ^:private data-app-client "data-app")
(defn has-react-sdk-header?
"Check if the client has indicated it is from the Embedding SDK for React."
@@ -15,10 +16,9 @@
Unlike its siblings here this one gates authorization, not behaviour:
[[metabase.server.middleware.data-app-scope]] confines a request to the `data-app` scope
- on the strength of it, so the client name must stay in sync with
- `EMBEDDING_SDK_CONFIG.metabaseClientRequestHeader` on the FE."
+ on the strength of it."
[request]
- (= (get-in request [:headers "x-metabase-client"]) data-app-client))
+ (analytics/data-app-client? (get-in request [:headers "x-metabase-client"])))
(defn has-embedded-analytics-js-header?
"Check if the client has indicated it is from modular embedding."
diff --git a/src/metabase/view_log/events/view_log.clj b/src/metabase/view_log/events/view_log.clj
index 239683238bc..b7f27431789 100644
--- a/src/metabase/view_log/events/view_log.clj
+++ b/src/metabase/view_log/events/view_log.clj
@@ -154,20 +154,22 @@
(catch Throwable e
(log/warnf "Failed to process view event. %s: %s" topic (ex-message e))))))
-(events/derive! ::card-query-model-view :metabase/event)
-(events/derive! :event/card-query ::card-query-model-view)
+(events/derive! ::card-query-view :metabase/event)
+(events/derive! :event/card-query ::card-query-view)
-(m/defmethod events/publish-event! ::card-query-model-view
- "Log a view for models, which are opened as ad-hoc `card__id` queries that fire :event/card-query but never
- :event/card-read. The :ad-hoc + model guards keep regular cards (logged via card-read) and downloads out."
+(m/defmethod events/publish-event! ::card-query-view
+ "Log a view for the cards read through ad-hoc `card__id` queries, which never fire `:event/card-read`: models, and
+ the saved questions a published data app queries. Only ad-hoc queries count, which keeps downloads out. Other
+ ad-hoc queries on a regular question are left out too: opening the question is logged as its card-read."
[topic {:keys [card-id user-id context]}]
(span/with-span!
- {:name "view-log-model-query"
+ {:name "view-log-card-query"
:topic topic
:user-id user-id}
(try
(when (and (= context :ad-hoc)
- (= :model (view-log.db/card-type card-id)))
+ (or (analytics/data-app-client?)
+ (= :model (view-log.db/card-type card-id))))
(increment-view-counts! :model/Card card-id)
(record-views! (generate-view :model :model/Card
:object-id card-id
diff --git a/test/metabase/view_log/events/view_log_test.clj b/test/metabase/view_log/events/view_log_test.clj
index cc6e7a07a6a..7a3df72afee 100644
--- a/test/metabase/view_log/events/view_log_test.clj
+++ b/test/metabase/view_log/events/view_log_test.clj
@@ -89,6 +89,37 @@
(is (= 1 (t2/count :model/ViewLog :user_id (u/id user) :model_id (u/id model)))
"only the ad-hoc view is recorded")))))
+(deftest card-query-data-app-read-ee-test
+ (mt/with-premium-features #{:audit-app}
+ (mt/with-temp [:model/User user {}
+ :model/Card published {:type :question :creator_id (u/id user)}
+ :model/Card preview {:type :question :creator_id (u/id user)}
+ :model/Card sdk-question {:type :question :creator_id (u/id user)}
+ :model/Card download {:type :question :creator_id (u/id user)}]
+ (testing "An ad-hoc card-query a published data app runs on a question is recorded as a card view"
+ (sdk/with-client! ["data-app"]
+ (binding [sdk/*client-identifier* "product-reviews"]
+ (events/publish-event! :event/card-query
+ {:card-id (u/id published) :user-id (u/id user) :context :ad-hoc})))
+ (is (partial= {:user_id (u/id user)
+ :model "card"
+ :model_id (u/id published)
+ :context :question
+ :has_access true
+ :embedding_client "data-app"
+ :embedding_client_identifier "product-reviews"}
+ (latest-view (u/id user) (u/id published)))))
+ (testing "Other clients' ad-hoc card-queries aren't recorded, a data app's dev preview included"
+ (doseq [[client card] [["data-app-preview" preview] ["embedding-sdk-react" sdk-question]]]
+ (testing client
+ (sdk/with-client! [client]
+ (events/publish-event! :event/card-query {:card-id (u/id card) :user-id (u/id user) :context :ad-hoc}))
+ (is (nil? (latest-view (u/id user) (u/id card)))))))
+ (testing "A data app's non-ad-hoc card-query is not recorded"
+ (sdk/with-client! ["data-app"]
+ (events/publish-event! :event/card-query {:card-id (u/id download) :user-id (u/id user) :context :csv-download}))
+ (is (nil? (latest-view (u/id user) (u/id download))))))))
+
(deftest collection-read-ee-test
(mt/with-premium-features #{:audit-app}
(mt/with-temp [:model/Collection coll {}]
@@ -327,6 +358,36 @@
(is (partial= {:user_id (mt/user->id :crowberto) :model "card" :model_id (u/id model) :context :question}
(latest-view (mt/user->id :crowberto) (u/id model)))))))))
+(deftest data-app-dataset-query-view-log-test
+ (mt/with-premium-features #{:audit-app}
+ (mt/with-temp [:model/Card published {:name "Bird sightings"
+ :type :question
+ :dataset_query (mt/mbql-query venues {:limit 1})}
+ :model/Card preview {:name "Bird sightings preview"
+ :type :question
+ :dataset_query (mt/mbql-query venues {:limit 1})}]
+ (let [data-app-headers {"x-metabase-client" "data-app"
+ "x-metabase-client-identifier" "bird-watch"}
+ read-as-data-app! (fn [card extra-headers]
+ (mt/user-http-request
+ :crowberto :post 202 "dataset"
+ {:request-options {:headers (merge data-app-headers extra-headers)}}
+ {:database (mt/id)
+ :type :query
+ :query {:source-table (str "card__" (u/id card))}}))]
+ (testing "A question a published data app reads through POST /api/dataset is recorded from the request headers"
+ (read-as-data-app! published {})
+ (is (partial= {:user_id (mt/user->id :crowberto)
+ :model "card"
+ :model_id (u/id published)
+ :context :question
+ :embedding_client "data-app"
+ :embedding_client_identifier "bird-watch"}
+ (latest-view (mt/user->id :crowberto) (u/id published)))))
+ (testing "A data app's dev preview reading a question is not recorded"
+ (read-as-data-app! preview {"x-metabase-embedded-preview" "true"})
+ (is (nil? (latest-view (mt/user->id :crowberto) (u/id preview)))))))))
+
(deftest get-dashboard-view-log-test
(mt/with-premium-features #{:audit-app}
(testing "Dashboard reads (views) via the API are recorded in the view_log"