| // Copyright (C) 2025 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| import m from 'mithril'; |
| import { |
| LONG_NULL, |
| NUM_NULL, |
| STR_NULL, |
| } from '../../../trace_processor/query_result'; |
| import {Icon} from '../../../widgets/icon'; |
| import {Tooltip} from '../../../widgets/tooltip'; |
| import {Section} from '../../../widgets/section'; |
| import {Card} from '../../../widgets/card'; |
| import {GridLayout} from '../../../widgets/grid_layout'; |
| import {EmptyState} from '../../../widgets/empty_state'; |
| import {Callout} from '../../../widgets/callout'; |
| import {Intent} from '../../../widgets/common'; |
| import type {Trace} from '../../../public/trace'; |
| import type {duration} from '../../../base/time'; |
| import {formatDuration} from '../../../components/time_utils'; |
| import type {TabKey} from '../utils'; |
| import {formatFileSize} from '../../../base/file_utils'; |
| |
| export interface OverviewData { |
| // Status counts |
| importErrors: number; |
| traceErrors: number; |
| dataLosses: number; |
| uiLoadingErrorCount: number; |
| // Metrics |
| traceSizeBytes?: bigint; |
| traceTypes: string[]; |
| uuid?: string; |
| durationNs?: duration; |
| schedDurationNs?: duration; |
| // System information |
| androidBuildFingerprint?: string; |
| systemName?: string; |
| systemMachine?: string; |
| systemRelease?: string; |
| // Multi-trace/machine counts |
| traceCount: number; |
| machineCount: number; |
| } |
| |
| export async function loadOverviewData(trace: Trace): Promise<OverviewData> { |
| // Load everything in a single query |
| const result = await trace.engine.query(` |
| SELECT |
| -- Status card counts |
| (SELECT IFNULL(sum(value), 0) FROM stats WHERE severity = 'error' AND source = 'analysis') as import_errors, |
| (SELECT IFNULL(sum(value), 0) FROM stats WHERE severity = 'error' AND source = 'trace') as trace_errors, |
| (SELECT IFNULL(sum(value), 0) FROM stats WHERE severity = 'data_loss') as data_losses, |
| -- Metrics |
| extract_metadata('trace_size_bytes') as trace_size_bytes, |
| extract_metadata('tracing_disabled_ns') - |
| extract_metadata('tracing_started_ns') as duration_ns, |
| (SELECT max(ts) - min(ts) FROM sched) as sched_duration_ns, |
| -- System info |
| extract_metadata('system_name') as system_name, |
| extract_metadata('system_release') as system_release, |
| extract_metadata('system_machine') as system_machine, |
| extract_metadata('android_build_fingerprint') as android_build_fingerprint, |
| (SELECT COUNT(DISTINCT trace_id) FROM metadata WHERE trace_id IS NOT NULL) as trace_count, |
| (SELECT COUNT(DISTINCT machine_id) FROM metadata WHERE machine_id IS NOT NULL) as machine_count; |
| `); |
| |
| const row = result.firstRow({ |
| import_errors: NUM_NULL, |
| trace_errors: NUM_NULL, |
| data_losses: NUM_NULL, |
| trace_size_bytes: LONG_NULL, |
| duration_ns: LONG_NULL, |
| sched_duration_ns: LONG_NULL, |
| system_name: STR_NULL, |
| system_release: STR_NULL, |
| system_machine: STR_NULL, |
| android_build_fingerprint: STR_NULL, |
| trace_count: NUM_NULL, |
| machine_count: NUM_NULL, |
| }); |
| return { |
| importErrors: row.import_errors ?? 0, |
| traceErrors: row.trace_errors ?? 0, |
| dataLosses: row.data_losses ?? 0, |
| uiLoadingErrorCount: trace.loadingErrors.length, |
| traceSizeBytes: row.trace_size_bytes ?? undefined, |
| traceTypes: trace.traceInfo.traceTypes, |
| uuid: trace.traceInfo.uuid, |
| durationNs: row.duration_ns ?? undefined, |
| schedDurationNs: row.sched_duration_ns ?? undefined, |
| androidBuildFingerprint: row.android_build_fingerprint ?? undefined, |
| systemName: row.system_name ?? undefined, |
| systemMachine: row.system_machine ?? undefined, |
| systemRelease: row.system_release ?? undefined, |
| traceCount: row.trace_count ?? 0, |
| machineCount: row.machine_count ?? 0, |
| }; |
| } |
| |
| export interface OverviewTabAttrs { |
| trace: Trace; |
| data: OverviewData; |
| onTabChange(key: TabKey): void; |
| } |
| |
| interface StatusCardConfig { |
| title: string; |
| count: number; |
| severity: 'success' | 'danger' | 'warning'; |
| icon: string; |
| helpText: string; |
| targetTab: TabKey; |
| } |
| |
| interface MetricCardConfig { |
| label: string; |
| value: string | undefined; |
| help?: string; |
| wide?: boolean; |
| } |
| |
| export class OverviewTab implements m.ClassComponent<OverviewTabAttrs> { |
| view({attrs}: m.CVnode<OverviewTabAttrs>) { |
| return m( |
| '.pf-trace-info-page__tab-content', |
| attrs.data.traceCount > 1 && |
| m( |
| Callout, |
| { |
| icon: 'layers', |
| intent: Intent.Primary, |
| className: 'pf-trace-info-page__banner', |
| }, |
| 'This session contains multiple traces. See the "Traces" tab for details.', |
| ), |
| attrs.data.machineCount > 1 && |
| m( |
| Callout, |
| { |
| icon: 'computer', |
| intent: Intent.Primary, |
| className: 'pf-trace-info-page__banner', |
| }, |
| 'This session contains data from multiple machines. See the "Machines" tab for details.', |
| ), |
| this.renderCardSection( |
| 'Trace Health', |
| 'Summary of errors, warnings, and data quality indicators', |
| createStatusCards(attrs.data).map((card) => |
| renderStatusCard(attrs, card), |
| ), |
| ), |
| this.renderCardSection( |
| 'Trace Overview', |
| 'Key metadata and properties of the trace file', |
| createTraceMetrics(attrs.trace, attrs.data).map((metric) => |
| renderMetricCard(metric), |
| ), |
| ), |
| this.renderCardSection( |
| 'System Information', |
| 'Operating system and hardware details from the traced device', |
| createSystemInfoMetrics(attrs.data).map((metric) => |
| renderMetricCard(metric), |
| ), |
| { |
| emptyState: { |
| icon: 'computer', |
| title: 'No system information available', |
| }, |
| }, |
| ), |
| ); |
| } |
| |
| private renderCardSection( |
| title: string, |
| subtitle: string, |
| cards: m.Children[], |
| options?: {emptyState?: {icon: string; title: string}}, |
| ): m.Children { |
| const filteredCards = cards.filter(Boolean); |
| return m( |
| Section, |
| {title, subtitle}, |
| filteredCards.length === 0 && options?.emptyState |
| ? m(EmptyState, options.emptyState) |
| : m(GridLayout, {}, ...filteredCards), |
| ); |
| } |
| } |
| |
| function renderStatusCard( |
| attrs: OverviewTabAttrs, |
| {title, count, severity, icon, helpText, targetTab}: StatusCardConfig, |
| ): m.Children { |
| const isClickable = count > 0; |
| const className = `pf-trace-info-page__status-card pf-trace-info-page__status-card--${severity}${ |
| isClickable ? ' pf-trace-info-page__status-card--clickable' : '' |
| }`; |
| |
| return m( |
| Card, |
| { |
| className, |
| onclick: isClickable ? () => attrs.onTabChange(targetTab) : undefined, |
| }, |
| m( |
| '.pf-trace-info-page__status-card-main', |
| m(Icon, { |
| icon, |
| className: 'pf-trace-info-page__status-icon', |
| filled: true, |
| }), |
| m( |
| '.pf-trace-info-page__status-content', |
| m( |
| '.pf-trace-info-page__status-title', |
| title, |
| m( |
| Tooltip, |
| { |
| trigger: m(Icon, { |
| icon: 'help_outline', |
| className: 'pf-trace-info-page__help-icon', |
| }), |
| }, |
| helpText, |
| ), |
| ), |
| m('.pf-trace-info-page__status-value', count), |
| ), |
| isClickable && |
| m( |
| '.pf-trace-info-page__status-link', |
| m(Icon, { |
| icon: 'arrow_forward', |
| className: 'pf-trace-info-page__status-link-icon', |
| }), |
| ), |
| ), |
| ); |
| } |
| |
| function renderMetricCard({ |
| label, |
| value, |
| help, |
| wide, |
| }: MetricCardConfig): m.Children { |
| if (value === undefined) { |
| return null; |
| } |
| const className = wide |
| ? 'pf-trace-info-page__metric-card pf-trace-info-page__metric-card--wide' |
| : 'pf-trace-info-page__metric-card'; |
| return m( |
| Card, |
| {className}, |
| m( |
| '.pf-trace-info-page__metric-content', |
| m( |
| '.pf-trace-info-page__metric-label', |
| label, |
| help && |
| m( |
| Tooltip, |
| { |
| trigger: m(Icon, { |
| icon: 'help_outline', |
| className: 'pf-trace-info-page__help-icon', |
| }), |
| }, |
| help, |
| ), |
| ), |
| m('.pf-trace-info-page__metric-value', value), |
| ), |
| ); |
| } |
| |
| function createStatusCards(data: OverviewData): StatusCardConfig[] { |
| const statusCards: StatusCardConfig[] = [ |
| { |
| title: 'Import Errors', |
| count: data.importErrors, |
| severity: data.importErrors === 0 ? 'success' : 'danger', |
| icon: data.importErrors === 0 ? 'check_circle' : 'error', |
| helpText: |
| 'Errors encountered during trace import by the trace processor. These may indicate missing or corrupted data.', |
| targetTab: data.importErrors > 0 ? 'import_errors' : 'stats', |
| }, |
| { |
| title: 'Trace Errors', |
| count: data.traceErrors, |
| severity: data.traceErrors === 0 ? 'success' : 'danger', |
| icon: data.traceErrors === 0 ? 'check_circle' : 'error', |
| helpText: |
| 'Errors that occurred during trace recording. These indicate problems during data collection.', |
| targetTab: data.traceErrors > 0 ? 'trace_errors' : 'stats', |
| }, |
| { |
| title: 'Data Losses', |
| count: data.dataLosses, |
| severity: data.dataLosses === 0 ? 'success' : 'warning', |
| icon: data.dataLosses === 0 ? 'check_circle' : 'warning', |
| helpText: |
| 'Events that were dropped during trace recording due to buffer overflow or other issues.', |
| targetTab: data.dataLosses > 0 ? 'data_losses' : 'stats', |
| }, |
| ]; |
| // Optional UI loading errors card - only show if there are errors |
| if (data.uiLoadingErrorCount > 0) { |
| statusCards.push({ |
| title: 'UI Loading Errors', |
| count: data.uiLoadingErrorCount, |
| severity: 'danger', |
| icon: 'error', |
| helpText: |
| 'Errors that occurred in the UI while loading or processing the trace.', |
| targetTab: 'ui_loading_errors', |
| }); |
| } |
| return statusCards; |
| } |
| |
| function createTraceMetrics( |
| trace: Trace, |
| data: OverviewData, |
| ): MetricCardConfig[] { |
| return [ |
| { |
| label: 'Trace Size', |
| value: |
| data.traceSizeBytes !== undefined |
| ? formatFileSize(Number(data.traceSizeBytes)) |
| : undefined, |
| help: 'Total size of the trace file on disk', |
| }, |
| { |
| label: 'Trace Type', |
| value: |
| data.traceTypes.length > 0 ? data.traceTypes.join(', ') : 'Unknown', |
| help: 'Format of the trace file (proto, json, etc.)', |
| }, |
| { |
| label: 'Recording Duration', |
| value: |
| data.durationNs !== undefined |
| ? formatDuration(trace, data.durationNs) |
| : undefined, |
| help: 'Time between tracing_started and tracing_disabled', |
| }, |
| { |
| label: 'Scheduling Duration', |
| value: |
| data.schedDurationNs !== undefined |
| ? formatDuration(trace, data.schedDurationNs) |
| : undefined, |
| help: 'Duration from first to last scheduling event (max(ts) - min(ts) from sched)', |
| }, |
| { |
| label: 'Trace UUID', |
| value: data.uuid, |
| help: |
| data.traceCount > 1 |
| ? 'Session-wide identifier. Individual UUIDs are in the "Traces" tab.' |
| : 'Unique identifier for this trace session', |
| wide: true, |
| }, |
| ]; |
| } |
| |
| function createSystemInfoMetrics(data: OverviewData): MetricCardConfig[] { |
| return [ |
| { |
| label: 'Android Fingerprint', |
| value: data.androidBuildFingerprint, |
| help: 'Unique build identifier for Android devices', |
| wide: true, |
| }, |
| { |
| label: 'Operating System', |
| value: data.systemName, |
| help: 'Operating system name from uname', |
| }, |
| { |
| label: 'Architecture', |
| value: data.systemMachine, |
| help: 'System architecture (e.g., x86_64, aarch64)', |
| }, |
| { |
| label: 'Kernel Release', |
| value: data.systemRelease, |
| help: 'Kernel version string', |
| wide: true, |
| }, |
| ]; |
| } |
