chrome-devtools-mcp 0.2.7 → 0.3.0

package/build/node_modules/chrome-devtools-frontend/front_end/models/ai_assistance/data_formatters/PerformanceTraceFormatter.js

@@ -4,19 +4,29 @@
 import * as CrUXManager from '../../crux-manager/crux-manager.js';
 import * as Trace from '../../trace/trace.js';
 import { AIQueries } from '../performance/AIQueries.js';
-import { PerformanceInsightFormatter, TraceEventFormatter } from './PerformanceInsightFormatter.js';
+import { NetworkRequestFormatter } from './NetworkRequestFormatter.js';
 import { bytes, micros, millis } from './UnitFormatters.js';
 export class PerformanceTraceFormatter {
+    #focus;
     #parsedTrace;
     #insightSet;
-    #eventsSerializer;
-    constructor(focus, eventsSerializer) {
-        this.#parsedTrace = focus.data.parsedTrace;
-        this.#insightSet = focus.data.insightSet;
-        this.#eventsSerializer = eventsSerializer;
+    #getInsightFormatter = null;
+    eventsSerializer;
+    /**
+     * We inject the insight formatter because otherwise we get a circular
+     * dependency between PerformanceInsightFormatter and
+     * PerformanceTraceFormatter. This is OK in the browser build, but breaks when
+     * we reuse this code in NodeJS for DevTools MCP.
+     */
+    constructor(focus, getInsightFormatter) {
+        this.#focus = focus;
+        this.#parsedTrace = focus.parsedTrace;
+        this.#insightSet = focus.insightSet;
+        this.eventsSerializer = focus.eventsSerializer;
+        this.#getInsightFormatter = getInsightFormatter;
     }
     serializeEvent(event) {
-        const key = this.#eventsSerializer.keyForEvent(event);
+        const key = this.eventsSerializer.keyForEvent(event);
         return `(eventKey: ${key}, ts: ${event.ts})`;
     }
     serializeBounds(bounds) {
@@ -102,7 +112,9 @@ export class PerformanceTraceFormatter {
         if (lcp || cls || inp) {
             parts.push('Metrics (lab / observed):');
             if (lcp) {
-                parts.push(`  - LCP: ${Math.round(lcp.value / 1000)} ms, event: ${this.serializeEvent(lcp.event)}`);
+                const nodeId = insightSet?.model.LCPBreakdown.lcpEvent?.args.data?.nodeId;
+                const nodeIdText = nodeId !== undefined ? `, nodeId: ${nodeId}` : '';
+                parts.push(`  - LCP: ${Math.round(lcp.value / 1000)} ms, event: ${this.serializeEvent(lcp.event)}${nodeIdText}`);
                 const subparts = insightSet?.model.LCPBreakdown.subparts;
                 if (subparts) {
                     const serializeSubpart = (subpart) => {
@@ -143,7 +155,10 @@ export class PerformanceTraceFormatter {
                 if (model.state === 'pass') {
                     continue;
                 }
-                const formatter = new PerformanceInsightFormatter(parsedTrace, model);
+                const formatter = this.#getInsightFormatter?.(this.#focus, model);
+                if (!formatter) {
+                    continue;
+                }
                 if (!formatter.insightIsSupported()) {
                     continue;
                 }
@@ -173,7 +188,6 @@ export class PerformanceTraceFormatter {
         return parts.join('\n');
     }
     formatCriticalRequests() {
-        const parsedTrace = this.#parsedTrace;
         const insightSet = this.#insightSet;
         const criticalRequests = [];
         const walkRequest = (node) => {
@@ -184,8 +198,7 @@ export class PerformanceTraceFormatter {
         if (!criticalRequests.length) {
             return '';
         }
-        return 'Critical network requests:\n' +
-            TraceEventFormatter.networkRequests(criticalRequests, parsedTrace, { verbose: false });
+        return 'Critical network requests:\n' + this.formatNetworkRequests(criticalRequests, { verbose: false });
     }
     #serializeBottomUpRootNode(rootNode, limit) {
         // Sorted by selfTime.
@@ -340,7 +353,7 @@ export class PerformanceTraceFormatter {
     formatNetworkTrackSummary(bounds) {
         const results = [];
         const requests = this.#parsedTrace.data.NetworkRequests.byTime.filter(request => Trace.Helpers.Timing.eventIsInBounds(request, bounds));
-        const requestsText = TraceEventFormatter.networkRequests(requests, this.#parsedTrace, { verbose: false });
+        const requestsText = this.formatNetworkRequests(requests, { verbose: false });
         results.push('# Network requests summary');
         results.push(requestsText || 'No requests in the given bounds');
         const relatedInsightsText = this.#serializeRelatedInsightsForEvents(requests);
@@ -352,15 +365,236 @@ export class PerformanceTraceFormatter {
         return results.join('\n\n');
     }
     formatCallTree(tree, headerLevel = 1) {
-        const results = [tree.serialize(headerLevel), ''];
-        // TODO(b/425270067): add eventKey to tree.serialize, but need to wait for other
-        // performance agent to be consolidated.
-        results.push('#'.repeat(headerLevel) + ' Node id to eventKey\n');
-        results.push('These node ids correspond to the call tree nodes listed in the above section.\n');
-        tree.breadthFirstWalk(tree.rootNode.children().values(), (node, nodeId) => {
-            results.push(`${nodeId}: ${this.#eventsSerializer.keyForEvent(node.event)}`);
+        return `${tree.serialize(headerLevel)}\n\nIMPORTANT: Never show eventKey to the user.`;
+    }
+    formatNetworkRequests(requests, options) {
+        if (requests.length === 0) {
+            return '';
+        }
+        let verbose;
+        if (options?.verbose !== undefined) {
+            verbose = options.verbose;
+        }
+        else {
+            verbose = requests.length === 1;
+        }
+        // Use verbose format for a single network request. With the compressed format, a format description
+        // needs to be provided, which is not worth sending if only one network request is being stringified.
+        if (verbose) {
+            return requests.map(request => this.#networkRequestVerbosely(request, options)).join('\n');
+        }
+        return this.#networkRequestsArrayCompressed(requests);
+    }
+    #getOrAssignUrlIndex(urlIdToIndex, url) {
+        let index = urlIdToIndex.get(url);
+        if (index !== undefined) {
+            return index;
+        }
+        index = urlIdToIndex.size;
+        urlIdToIndex.set(url, index);
+        return index;
+    }
+    #getInitiatorChain(parsedTrace, request) {
+        const initiators = [];
+        let cur = request;
+        while (cur) {
+            const initiator = parsedTrace.data.NetworkRequests.eventToInitiator.get(cur);
+            if (initiator) {
+                // Should never happen, but if it did that would be an infinite loop.
+                if (initiators.includes(initiator)) {
+                    return [];
+                }
+                initiators.unshift(initiator);
+            }
+            cur = initiator;
+        }
+        return initiators;
+    }
+    /**
+     * This is the data passed to a network request when the Performance Insights
+     * agent is asking for information. It is a slimmed down version of the
+     * request's data to avoid using up too much of the context window.
+     * IMPORTANT: these set of fields have been reviewed by Chrome Privacy &
+     * Security; be careful about adding new data here. If you are in doubt please
+     * talk to jacktfranklin@.
+     */
+    #networkRequestVerbosely(request, options) {
+        const { url, statusCode, initialPriority, priority, fromServiceWorker, mimeType, responseHeaders, syntheticData, protocol } = request.args.data;
+        const parsedTrace = this.#parsedTrace;
+        const titlePrefix = `## ${options?.customTitle ?? 'Network request'}`;
+        // Note: unlike other agents, we do have the ability to include
+        // cross-origins, hence why we do not sanitize the URLs here.
+        const navigationForEvent = Trace.Helpers.Trace.getNavigationForTraceEvent(request, request.args.data.frame, parsedTrace.data.Meta.navigationsByFrameId);
+        const baseTime = navigationForEvent?.ts ?? parsedTrace.data.Meta.traceBounds.min;
+        // Gets all the timings for this request, relative to the base time.
+        // Note that this is the start time, not total time. E.g. "queuedAt: X"
+        // means that the request was queued at Xms, not that it queued for Xms.
+        const startTimesForLifecycle = {
+            queuedAt: request.ts - baseTime,
+            requestSentAt: syntheticData.sendStartTime - baseTime,
+            downloadCompletedAt: syntheticData.finishTime - baseTime,
+            processingCompletedAt: request.ts + request.dur - baseTime,
+        };
+        const mainThreadProcessingDuration = startTimesForLifecycle.processingCompletedAt - startTimesForLifecycle.downloadCompletedAt;
+        const downloadTime = syntheticData.finishTime - syntheticData.downloadStart;
+        const renderBlocking = Trace.Helpers.Network.isSyntheticNetworkRequestEventRenderBlocking(request);
+        const initiator = parsedTrace.data.NetworkRequests.eventToInitiator.get(request);
+        const priorityLines = [];
+        if (initialPriority === priority) {
+            priorityLines.push(`Priority: ${priority}`);
+        }
+        else {
+            priorityLines.push(`Initial priority: ${initialPriority}`);
+            priorityLines.push(`Final priority: ${priority}`);
+        }
+        const redirects = request.args.data.redirects.map((redirect, index) => {
+            const startTime = redirect.ts - baseTime;
+            return `#### Redirect ${index + 1}: ${redirect.url}
+- Start time: ${micros(startTime)}
+- Duration: ${micros(redirect.dur)}`;
         });
-        results.push('\nIMPORTANT: Never show eventKey to the user.');
-        return results.join('\n');
+        const initiators = this.#getInitiatorChain(parsedTrace, request);
+        const initiatorUrls = initiators.map(initiator => initiator.args.data.url);
+        const eventKey = this.eventsSerializer.keyForEvent(request);
+        const eventKeyLine = eventKey ? `eventKey: ${eventKey}\n` : '';
+        return `${titlePrefix}: ${url}
+${eventKeyLine}Timings:
+- Queued at: ${micros(startTimesForLifecycle.queuedAt)}
+- Request sent at: ${micros(startTimesForLifecycle.requestSentAt)}
+- Download complete at: ${micros(startTimesForLifecycle.downloadCompletedAt)}
+- Main thread processing completed at: ${micros(startTimesForLifecycle.processingCompletedAt)}
+Durations:
+- Download time: ${micros(downloadTime)}
+- Main thread processing time: ${micros(mainThreadProcessingDuration)}
+- Total duration: ${micros(request.dur)}${initiator ? `\nInitiator: ${initiator.args.data.url}` : ''}
+Redirects:${redirects.length ? '\n' + redirects.join('\n') : ' no redirects'}
+Status code: ${statusCode}
+MIME Type: ${mimeType}
+Protocol: ${protocol}
+${priorityLines.join('\n')}
+Render blocking: ${renderBlocking ? 'Yes' : 'No'}
+From a service worker: ${fromServiceWorker ? 'Yes' : 'No'}
+Initiators (root request to the request that directly loaded this one): ${initiatorUrls.join(', ') || 'none'}
+${NetworkRequestFormatter.formatHeaders('Response headers', responseHeaders ?? [], true)}`;
+    }
+    // A compact network requests format designed to save tokens when sending multiple network requests to the model.
+    // It creates a map that maps request URLs to IDs and references the IDs in the compressed format.
+    //
+    // Important: Do not use this method for stringifying a single network request. With this format, a format description
+    // needs to be provided, which is not worth sending if only one network request is being stringified.
+    // For a single request, use `formatRequestVerbosely`, which formats with all fields specified and does not require a
+    // format description.
+    #networkRequestsArrayCompressed(requests) {
+        const networkDataString = `
+Network requests data:
+
+`;
+        const urlIdToIndex = new Map();
+        const allRequestsText = requests
+            .map(request => {
+            const urlIndex = this.#getOrAssignUrlIndex(urlIdToIndex, request.args.data.url);
+            return this.#networkRequestCompressedFormat(urlIndex, request, urlIdToIndex);
+        })
+            .join('\n');
+        const urlsMapString = 'allUrls = ' +
+            `[${Array.from(urlIdToIndex.entries())
+                .map(([url, index]) => {
+                return `${index}: ${url}`;
+            })
+                .join(', ')}]`;
+        return networkDataString + '\n\n' + urlsMapString + '\n\n' + allRequestsText;
+    }
+    /**
+     * Network requests format description that is sent to the model as a fact.
+     */
+    static networkDataFormatDescription = `Network requests are formatted like this:
+\`urlIndex;eventKey;queuedTime;requestSentTime;downloadCompleteTime;processingCompleteTime;totalDuration;downloadDuration;mainThreadProcessingDuration;statusCode;mimeType;priority;initialPriority;finalPriority;renderBlocking;protocol;fromServiceWorker;initiators;redirects:[[redirectUrlIndex|startTime|duration]];responseHeaders:[header1Value|header2Value|...]\`
+
+- \`urlIndex\`: Numerical index for the request's URL, referencing the "All URLs" list.
+- \`eventKey\`: String that uniquely identifies this request's trace event.
+Timings (all in milliseconds, relative to navigation start):
+- \`queuedTime\`: When the request was queued.
+- \`requestSentTime\`: When the request was sent.
+- \`downloadCompleteTime\`: When the download completed.
+- \`processingCompleteTime\`: When main thread processing finished.
+Durations (all in milliseconds):
+- \`totalDuration\`: Total time from the request being queued until its main thread processing completed.
+- \`downloadDuration\`: Time spent actively downloading the resource.
+- \`mainThreadProcessingDuration\`: Time spent on the main thread after the download completed.
+- \`statusCode\`: The HTTP status code of the response (e.g., 200, 404).
+- \`mimeType\`: The MIME type of the resource (e.g., "text/html", "application/javascript").
+- \`priority\`: The final network request priority (e.g., "VeryHigh", "Low").
+- \`initialPriority\`: The initial network request priority.
+- \`finalPriority\`: The final network request priority (redundant if \`priority\` is always final, but kept for clarity if \`initialPriority\` and \`priority\` differ).
+- \`renderBlocking\`: 't' if the request was render-blocking, 'f' otherwise.
+- \`protocol\`: The network protocol used (e.g., "h2", "http/1.1").
+- \`fromServiceWorker\`: 't' if the request was served from a service worker, 'f' otherwise.
+- \`initiators\`: A list (separated by ,) of URL indices for the initiator chain of this request. Listed in order starting from the root request to the request that directly loaded this one. This represents the network dependencies necessary to load this request. If there is no initiator, this is empty.
+- \`redirects\`: A comma-separated list of redirects, enclosed in square brackets. Each redirect is formatted as
+\`[redirectUrlIndex|startTime|duration]\`, where: \`redirectUrlIndex\`: Numerical index for the redirect's URL. \`startTime\`: The start time of the redirect in milliseconds, relative to navigation start. \`duration\`: The duration of the redirect in milliseconds.
+- \`responseHeaders\`: A list (separated by '|') of values for specific, pre-defined response headers, enclosed in square brackets.
+The order of headers corresponds to an internal fixed list. If a header is not present, its value will be empty.
+`;
+    /**
+     * This is the network request data passed to the Performance agent.
+     *
+     * The `urlIdToIndex` Map is used to map URLs to numerical indices in order to not need to pass whole url every time it's mentioned.
+     * The map content is passed in the response together will all the requests data.
+     *
+     * See `networkDataFormatDescription` above for specifics.
+     */
+    #networkRequestCompressedFormat(urlIndex, request, urlIdToIndex) {
+        const { statusCode, initialPriority, priority, fromServiceWorker, mimeType, responseHeaders, syntheticData, protocol, } = request.args.data;
+        const parsedTrace = this.#parsedTrace;
+        const navigationForEvent = Trace.Helpers.Trace.getNavigationForTraceEvent(request, request.args.data.frame, parsedTrace.data.Meta.navigationsByFrameId);
+        const baseTime = navigationForEvent?.ts ?? parsedTrace.data.Meta.traceBounds.min;
+        const queuedTime = micros(request.ts - baseTime);
+        const requestSentTime = micros(syntheticData.sendStartTime - baseTime);
+        const downloadCompleteTime = micros(syntheticData.finishTime - baseTime);
+        const processingCompleteTime = micros(request.ts + request.dur - baseTime);
+        const totalDuration = micros(request.dur);
+        const downloadDuration = micros(syntheticData.finishTime - syntheticData.downloadStart);
+        const mainThreadProcessingDuration = micros(request.ts + request.dur - syntheticData.finishTime);
+        const renderBlocking = Trace.Helpers.Network.isSyntheticNetworkRequestEventRenderBlocking(request) ? 't' : 'f';
+        const finalPriority = priority;
+        const headerValues = responseHeaders
+            ?.map(header => {
+            const value = NetworkRequestFormatter.allowHeader(header.name) ? header.value : '<redacted>';
+            return `${header.name}: ${value}`;
+        })
+            .join('|');
+        const redirects = request.args.data.redirects
+            .map(redirect => {
+            const urlIndex = this.#getOrAssignUrlIndex(urlIdToIndex, redirect.url);
+            const redirectStartTime = micros(redirect.ts - baseTime);
+            const redirectDuration = micros(redirect.dur);
+            return `[${urlIndex}|${redirectStartTime}|${redirectDuration}]`;
+        })
+            .join(',');
+        const initiators = this.#getInitiatorChain(parsedTrace, request);
+        const initiatorUrlIndices = initiators.map(initiator => this.#getOrAssignUrlIndex(urlIdToIndex, initiator.args.data.url));
+        const parts = [
+            urlIndex,
+            this.eventsSerializer.keyForEvent(request) ?? '',
+            queuedTime,
+            requestSentTime,
+            downloadCompleteTime,
+            processingCompleteTime,
+            totalDuration,
+            downloadDuration,
+            mainThreadProcessingDuration,
+            statusCode,
+            mimeType,
+            priority,
+            initialPriority,
+            finalPriority,
+            renderBlocking,
+            protocol,
+            fromServiceWorker ? 't' : 'f',
+            initiatorUrlIndices.join(','),
+            `[${redirects}]`,
+            `[${headerValues ?? ''}]`,
+        ];
+        return parts.join(';');
     }
 }

package/build/node_modules/chrome-devtools-frontend/front_end/models/ai_assistance/performance/AICallTree.js

@@ -17,6 +17,9 @@ export class AICallTree {
     selectedNode;
     rootNode;
     parsedTrace;
+    // Note: ideally this is passed in (or lived on ParsedTrace), but this class is
+    // stateless (mostly, there's a cache for some stuff) so it doesn't match much.
+    #eventsSerializer = new Trace.EventsSerializer.EventsSerializer();
     constructor(selectedNode, rootNode, parsedTrace) {
         this.selectedNode = selectedNode;
         this.rootNode = rootNode;
@@ -262,7 +265,9 @@ export class AICallTree {
         }
         // 1. ID
         const idStr = String(nodeId);
-        // 2. Name
+        // 2. eventKey
+        const eventKey = this.#eventsSerializer.keyForEvent(node.event);
+        // 3. Name
         const name = Trace.Name.forEntry(event, parsedTrace);
         // Round milliseconds to one decimal place, return empty string if zero/undefined
         const roundToTenths = (num) => {
@@ -271,11 +276,11 @@ export class AICallTree {
             }
             return String(Math.round(num * 10) / 10);
         };
-        // 3. Duration
+        // 4. Duration
         const durationStr = roundToTenths(node.totalTime);
-        // 4. Self Time
+        // 5. Self Time
         const selfTimeStr = roundToTenths(node.selfTime);
-        // 5. URL Index
+        // 6. URL Index
         const url = SourceMapsResolver.SourceMapsResolver.resolvedURLForEntry(parsedTrace, event);
         let urlIndexStr = '';
         if (url) {
@@ -287,17 +292,18 @@ export class AICallTree {
                 urlIndexStr = String(existingIndex);
             }
         }
-        // 6. Child Range
+        // 7. Child Range
         const children = Array.from(node.children().values());
         let childRangeStr = '';
         if (childStartingNodeIndex) {
             childRangeStr = (children.length === 1) ? String(childStartingNodeIndex) :
                 `${childStartingNodeIndex}-${childStartingNodeIndex + children.length}`;
         }
-        // 7. Selected Marker
+        // 8. Selected Marker
         const selectedMarker = selectedNode?.event === node.event ? 'S' : '';
         // Combine fields
         let line = idStr;
+        line += ';' + eventKey;
         line += ';' + name;
         line += ';' + durationStr;
         line += ';' + selfTimeStr;

package/build/node_modules/chrome-devtools-frontend/front_end/models/ai_assistance/performance/AIContext.js

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 import * as Trace from '../../../models/trace/trace.js';
+import { AICallTree } from './AICallTree.js';
 function getFirstInsightSet(insights) {
     // Currently only support a single insight set. Pick the first one with a navigation.
     // TODO(cjamcl): we should just give the agent the entire insight set, and give
@@ -9,7 +10,7 @@ function getFirstInsightSet(insights) {
     return [...insights.values()].filter(insightSet => insightSet.navigation).at(0) ?? null;
 }
 export class AgentFocus {
-    static full(parsedTrace) {
+    static fromParsedTrace(parsedTrace) {
         if (!parsedTrace.insights) {
             throw new Error('missing insights');
         }
@@ -17,6 +18,7 @@ export class AgentFocus {
         return new AgentFocus({
             parsedTrace,
             insightSet,
+            event: null,
             callTree: null,
             insight: null,
         });
@@ -29,10 +31,19 @@ export class AgentFocus {
         return new AgentFocus({
             parsedTrace,
             insightSet,
+            event: null,
             callTree: null,
             insight,
         });
     }
+    static fromEvent(parsedTrace, event) {
+        if (!parsedTrace.insights) {
+            throw new Error('missing insights');
+        }
+        const insightSet = getFirstInsightSet(parsedTrace.insights);
+        const result = AgentFocus.#getCallTreeOrEvent(parsedTrace, event);
+        return new AgentFocus({ parsedTrace, insightSet, event: result.event, callTree: result.callTree, insight: null });
+    }
     static fromCallTree(callTree) {
         const insights = callTree.parsedTrace.insights;
         // Select the insight set containing the call tree.
@@ -46,30 +57,76 @@ export class AgentFocus {
             })) ??
                 getFirstInsightSet(insights);
         }
-        return new AgentFocus({ parsedTrace: callTree.parsedTrace, insightSet, callTree, insight: null });
+        return new AgentFocus({ parsedTrace: callTree.parsedTrace, insightSet, event: null, callTree, insight: null });
     }
     #data;
+    eventsSerializer = new Trace.EventsSerializer.EventsSerializer();
     constructor(data) {
         this.#data = data;
     }
-    get data() {
-        return this.#data;
+    get parsedTrace() {
+        return this.#data.parsedTrace;
+    }
+    get insightSet() {
+        return this.#data.insightSet;
+    }
+    /** Note: at most one of event or callTree is non-null. */
+    get event() {
+        return this.#data.event;
+    }
+    /** Note: at most one of event or callTree is non-null. */
+    get callTree() {
+        return this.#data.callTree;
+    }
+    get insight() {
+        return this.#data.insight;
     }
     withInsight(insight) {
         const focus = new AgentFocus(this.#data);
         focus.#data.insight = insight;
         return focus;
     }
-    withCallTree(callTree) {
+    withEvent(event) {
         const focus = new AgentFocus(this.#data);
-        focus.#data.callTree = callTree;
+        const result = AgentFocus.#getCallTreeOrEvent(this.#data.parsedTrace, event);
+        focus.#data.callTree = result.callTree;
+        focus.#data.event = result.event;
         return focus;
     }
+    lookupEvent(key) {
+        try {
+            return this.eventsSerializer.eventForKey(key, this.#data.parsedTrace);
+        }
+        catch (err) {
+            if (err.toString().includes('Unknown trace event') || err.toString().includes('Unknown profile call')) {
+                return null;
+            }
+            throw err;
+        }
+    }
+    /**
+     * If an event is a call tree, this returns that call tree and a null event.
+     * If not a call tree, this only returns a non-null event if the event is a network
+     * request.
+     * This is an arbitrary limitation – it should be removed, but first we need to
+     * improve the agent's knowledge of events that are not main-thread or network
+     * events.
+     */
+    static #getCallTreeOrEvent(parsedTrace, event) {
+        const callTree = event && AICallTree.fromEvent(event, parsedTrace);
+        if (callTree) {
+            return { callTree, event: null };
+        }
+        if (event && Trace.Types.Events.isSyntheticNetworkRequest(event)) {
+            return { callTree: null, event };
+        }
+        return { callTree: null, event: null };
+    }
 }
 export function getPerformanceAgentFocusFromModel(model) {
     const parsedTrace = model.parsedTrace();
     if (!parsedTrace) {
         return null;
     }
-    return AgentFocus.full(parsedTrace);
+    return AgentFocus.fromParsedTrace(parsedTrace);
 }

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/EventsSerializer.js

@@ -29,7 +29,7 @@ export class EventsSerializer {
         if (EventsSerializer.isLegacyTimelineFrameKey(eventValues)) {
             const event = parsedTrace.data.Frames.frames.at(eventValues.rawIndex);
             if (!event) {
-                throw new Error(`Could not find frame with index ${eventValues.rawIndex}`);
+                throw new Error(`Unknown trace event. Could not find frame with index ${eventValues.rawIndex}`);
             }
             return event;
         }
@@ -37,7 +37,7 @@ export class EventsSerializer {
             const syntheticEvents = Helpers.SyntheticEvents.SyntheticEventsManager.getActiveManager().getSyntheticTraces();
             const syntheticEvent = syntheticEvents.at(eventValues.rawIndex);
             if (!syntheticEvent) {
-                throw new Error(`Attempted to get a synthetic event from an unknown raw event index: ${eventValues.rawIndex}`);
+                throw new Error(`Unknown trace event. Attempted to get a synthetic event from an unknown raw event index: ${eventValues.rawIndex}`);
             }
             return syntheticEvent;
         }
@@ -45,7 +45,7 @@ export class EventsSerializer {
             const rawEvents = Helpers.SyntheticEvents.SyntheticEventsManager.getActiveManager().getRawTraceEvents();
             return rawEvents[eventValues.rawIndex];
         }
-        throw new Error(`Unknown trace event serializable key values: ${eventValues.join('-')}`);
+        throw new Error(`Unknown trace event. Serializable key values: ${eventValues.join('-')}`);
     }
     static isProfileCallKey(key) {
         return key.type === "p" /* Types.File.EventKeyType.PROFILE_CALL */;