@paulirish/trace_engine 0.0.9 → 0.0.10

package/models/trace/handlers/UberFramesHandler.js

@@ -0,0 +1,293 @@
+import { data as metaHandlerData } from "./MetaHandler.js";
+import { HandlerState } from "./types.js";
+import * as Platform from "../../../core/platform/platform.js";
+import * as Helpers from "../helpers/helpers.js";
+import * as Types from "../types/types.js";
+const eventsInProcessThread = /* @__PURE__ */ new Map();
+let relevantEvts = [];
+const gpuEvents = [];
+const asyncEvts = [];
+let syntheticEvents = [];
+const waterFallEvents = [];
+let eventLatencyIdToFrameSeq = {};
+export function reset() {
+  eventsInProcessThread.clear();
+  relevantEvts.length = 0;
+  gpuEvents.length = 0;
+  syntheticEvents.length = 0;
+  asyncEvts.length = 0;
+  waterFallEvents.length = 0;
+  eventLatencyIdToFrameSeq = {};
+  handlerState = HandlerState.INITIALIZED;
+}
+let handlerState = HandlerState.UNINITIALIZED;
+const someStuff = {
+  CompositeLayers: "CompositeLayers",
+  RasterTask: "RasterTask",
+  ImageDecodeTask: "ImageDecodeTask",
+  ImageUploadTask: "ImageUploadTask",
+  DecodeImage: "Decode Image",
+  ResizeImage: "Resize Image",
+  DrawLazyPixelRef: "Draw LazyPixelRef",
+  DecodeLazyPixelRef: "Decode LazyPixelRef",
+  BeginFrame: "BeginFrame",
+  RequestMainThreadFrame: "RequestMainThreadFrame",
+  NeedsBeginFrameChanged: "NeedsBeginFrameChanged",
+  BeginMainThreadFrame: "BeginMainThreadFrame",
+  ActivateLayerTree: "ActivateLayerTree",
+  DrawFrame: "DrawFrame",
+  DroppedFrame: "DroppedFrame"
+};
+const someRelevantTraceEventTypes = [
+  ...Object.values(someStuff),
+  "ActivateLayerTree",
+  "BeginFrame",
+  "BeginMainThreadFrame,",
+  "CompositeLayers",
+  "Commit",
+  "DrawFrame",
+  "DroppedFrame",
+  "InvalidateLayout,",
+  "LayerTreeHostImplSnapshot",
+  "NeedsBeginFrameChanged",
+  "Paint",
+  "RequestMainThreadFrame",
+  "ScheduleStyleRecalculation,",
+  "ScrollLayer,",
+  "SetLayerTreeId",
+  "MainFrame.NotifyReadyToCommitOnImpl",
+  "MainFrame.CommitComplete",
+  "RasterizerTaskImpl::RunOnWorkerThread",
+  "LayerTreeHostImpl::FinishCommit",
+  "TileManager::FlushAndIssueSignals",
+  "ProxyImpl::ScheduledActionDraw",
+  "PipelineReporter",
+  "SendBeginMainFrameToCommit",
+  "BeginImplFrameToSendBeginMainFrame",
+  "SubmitCompositorFrameToPresentationCompositorFrame",
+  "RasterDecoderImpl::DoEndRasterCHROMIUM",
+  "Frame",
+  "Activation",
+  "BeginImplFrameToSendBeginMainFrame",
+  "Commit",
+  "EndActivateToSubmitCompositorFrame",
+  "EndCommitToActivation",
+  "ReceiveCompositorFrameToStartDraw",
+  "SendBeginMainFrameToCommit",
+  "StartDrawToSwapStart",
+  "SubmitCompositorFrameToPresentationCompositorFrame",
+  "SubmitToReceiveCompositorFrame",
+  "Swap",
+  "BeginFrame",
+  "DroppedFrame",
+  "RequestMainFrame",
+  "BeginMainThreadFrame",
+  "CompositeLayer",
+  "Commit",
+  "ActivateLayerTree",
+  "DrawFrame",
+  "EndCommitToActivation",
+  "Swap",
+  "SwapBuffers",
+  "Scheduler::BeginFrame",
+  "DisplayScheduler::BeginFrame",
+  "Scheduler::BeginImplFrame",
+  "EventLatency",
+  "GenerationToBrowserMain",
+  "BrowserMainToRendererCompositor",
+  "RendererCompositorQueueingDelay",
+  "RendererCompositorProcessing",
+  "RendererCompositorFinishedToEndActivate",
+  "RendererCompositorFinishedToSendBeginMainFrame",
+  "RendererCompositorFinishedToBeginImplFrame",
+  "BeginImplFrameToSendBeginMainFrame",
+  "RendererCompositorFinishedToCommit",
+  "RendererCompositorFinishedToEndCommit",
+  "RendererCompositorFinishedToActivation",
+  "RendererCompositorFinishedToSubmitCompositorFrame",
+  "RendererCompositorToMain",
+  "RendererMainProcessing",
+  "RendererMainFinishedToBeginImplFrame",
+  "RendererMainFinishedToSendBeginMainFrame",
+  "RendererMainFinishedToCommit",
+  "RendererMainFinishedToEndCommit",
+  "RendererMainFinishedToActivation",
+  "RendererMainFinishedToEndActivate",
+  "RendererMainFinishedToSubmitCompositorFrame",
+  "SendBeginMainFrameToCommit",
+  "Commit",
+  "EndCommitToActivation",
+  "Activation",
+  "EndActivateToSubmitCompositorFrame",
+  "SubmitCompositorFrameToPresentationCompositorFrame",
+  "SubmitCompositorFrameToPresentationCompositorFrame sub-stages:",
+  "SubmitToReceiveCompositorFrame",
+  "ReceiveCompositorFrameToStartDraw",
+  "StartDrawToSwapStart",
+  "Swap",
+  "SwapStartToBufferAvailable",
+  "BufferAvailableToBufferReady",
+  "BufferReadyToLatch",
+  "LatchToSwapEnd",
+  "SwapEndToPresentationCompositorFrame",
+  "EventTiming",
+  "LongAnimationFrame-pi",
+  "LongAnimationFrame-pi2",
+  "LongAnimationFrame-no2",
+  "LongAnimationFrame",
+  "LoAF-renderStart",
+  "LoAF-desiredRenderStart",
+  "LoAF-styleAndLayoutStart",
+  "ScreenshotMeta"
+];
+export const eventLatencyBreakdownTypeNames = [
+  "GenerationToBrowserMain",
+  "BrowserMainToRendererCompositor",
+  "RendererCompositorQueueingDelay",
+  "RendererCompositorProcessing",
+  "RendererCompositorFinishedToEndActivate",
+  "RendererCompositorFinishedToSendBeginMainFrame",
+  "RendererCompositorFinishedToBeginImplFrame",
+  "BeginImplFrameToSendBeginMainFrame",
+  "RendererCompositorFinishedToCommit",
+  "RendererCompositorFinishedToEndCommit",
+  "RendererCompositorFinishedToActivation",
+  "RendererCompositorFinishedToSubmitCompositorFrame",
+  "RendererCompositorToMain",
+  "RendererMainProcessing",
+  "RendererMainFinishedToBeginImplFrame",
+  "RendererMainFinishedToSendBeginMainFrame",
+  "RendererMainFinishedToCommit",
+  "RendererMainFinishedToEndCommit",
+  "RendererMainFinishedToActivation",
+  "RendererMainFinishedToEndActivate",
+  "RendererMainFinishedToSubmitCompositorFrame",
+  "SendBeginMainFrameToCommit",
+  "Commit",
+  "EndCommitToActivation",
+  "Activation",
+  "EndActivateToSubmitCompositorFrame",
+  "SubmitToReceiveCompositorFrame",
+  "ReceiveCompositorFrameToStartDraw",
+  "StartDrawToSwapStart",
+  "Swap",
+  "SwapStartToBufferAvailable",
+  "BufferAvailableToBufferReady",
+  "BufferReadyToLatch",
+  "LatchToSwapEnd",
+  "SwapEndToPresentationCompositorFrame"
+];
+export const waterfallTypes = /* @__PURE__ */ new Map([
+  ["EventLatency", 4],
+  ["SendBeginMainFrameToCommit", 3],
+  ["EndCommitToActivation", 2],
+  ["Activation", 2],
+  ["EndActivateToSubmitCompositorFrame", 2],
+  ["SubmitCompositorFrameToPresentationCompositorFrame", 2]
+]);
+export function handleEvent(event) {
+  if (Types.TraceEvents.isTraceEventGPUTask(event)) {
+    gpuEvents.push(event);
+    Helpers.Trace.addEventToProcessThread(event, eventsInProcessThread);
+  } else if (event.name === "Screenshot" || someRelevantTraceEventTypes.some((type) => event.name === type)) {
+    if (event.ph === "b" || event.ph === "e") {
+      asyncEvts.push(event);
+    } else {
+      if (eventLatencyBreakdownTypeNames.includes(event.name)) {
+        if (event.name === "Commit" && !event.cat.includes("cc")) {
+        } else {
+          waterFallEvents.push(event);
+        }
+      }
+      relevantEvts.push(event);
+    }
+    Helpers.Trace.addEventToProcessThread(event, eventsInProcessThread);
+  }
+}
+export async function finalize() {
+  const { browserProcessId, browserThreadId } = metaHandlerData();
+  const browserThreads = eventsInProcessThread.get(browserProcessId);
+  const { gpuProcessId, gpuThreadId, topLevelRendererIds } = metaHandlerData();
+  const ourRendererGPUTasks = gpuEvents.filter((e) => topLevelRendererIds.has(e.args.data.renderer_pid));
+  relevantEvts = [...relevantEvts, ...ourRendererGPUTasks];
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("UberFrames handler is not initialized");
+  }
+  const matchedEvents = /* @__PURE__ */ new Map();
+  for (const event of [...asyncEvts]) {
+    const id = Helpers.Trace.extractId(event);
+    if (id === void 0) {
+      continue;
+    }
+    const syntheticId = `${event.cat}:${id}:${event.name}`;
+    const otherEventsWithID = Platform.MapUtilities.getWithDefault(matchedEvents, syntheticId, () => {
+      return { begin: null, end: null };
+    });
+    const isStartEvent = event.ph === Types.TraceEvents.Phase.ASYNC_NESTABLE_START;
+    const isEndEvent = event.ph === Types.TraceEvents.Phase.ASYNC_NESTABLE_END;
+    if (isStartEvent) {
+      otherEventsWithID.begin = event;
+    } else if (isEndEvent) {
+      otherEventsWithID.end = event;
+    }
+  }
+  for (const [id, eventsPair] of matchedEvents.entries()) {
+    if (!eventsPair.begin || !eventsPair.end) {
+      continue;
+    }
+    const event = {
+      cat: eventsPair.end.cat,
+      ph: "X",
+      pid: eventsPair.end.pid,
+      tid: eventsPair.end.tid,
+      id,
+      name: eventsPair.begin.name,
+      dur: Types.Timing.MicroSeconds(eventsPair.end.ts - eventsPair.begin.ts),
+      ts: eventsPair.begin.ts,
+      args: {
+        data: {
+          beginEvent: eventsPair.begin,
+          endEvent: eventsPair.end
+        }
+      }
+    };
+    if (event.name === "EventLatency") {
+      eventLatencyIdToFrameSeq[eventsPair.begin.id2.local] = eventsPair.begin.args.event_latency.frame_sequence ?? null;
+    }
+    if (event.name === "PipelineReporter") {
+      eventLatencyIdToFrameSeq[eventsPair.begin.id2.local] = eventsPair.begin.args.chrome_frame_reporter.frame_sequence ?? null;
+    }
+    const existingDuplicate = syntheticEvents.find((e) => {
+      return e.name === event.name && e.ts === event.ts && e.dur === event.dur && e.id2?.local === event.id2?.local && e.tid === event.tid && e.pid === event.pid;
+    });
+    if (existingDuplicate) {
+      continue;
+    }
+    if (eventLatencyBreakdownTypeNames.includes(event.name)) {
+      waterFallEvents.push(event);
+    }
+    syntheticEvents.push(event);
+  }
+  syntheticEvents = syntheticEvents.filter((e) => {
+    return true;
+    if (e.name !== "PipelineReporter") {
+      return true;
+    }
+    return topLevelRendererIds.has(e.pid) && e.args.data.beginEvent.args.chrome_frame_reporter.frame_type !== "FORKED" && e.args.data.beginEvent.args.chrome_frame_reporter.state === "STATE_PRESENTED_ALL";
+  });
+  handlerState = HandlerState.FINALIZED;
+}
+export function data() {
+  if (handlerState !== HandlerState.FINALIZED) {
+    throw new Error("UberFrames handler is not finalized");
+  }
+  return {
+    nonWaterfallEvts: [...relevantEvts, ...syntheticEvents].sort((event1, event2) => event1.ts - event2.ts),
+    waterFallEvts: [...waterFallEvents].sort((event1, event2) => event1.ts - event2.ts),
+    eventLatencyIdToFrameSeq
+  };
+}
+export function deps() {
+  return ["Meta"];
+}
+//# sourceMappingURL=UberFramesHandler.js.map

package/models/trace/handlers/UberFramesHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/UberFramesHandler.ts"],
+  "sourcesContent": ["// Copyright 2022 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport {data as metaHandlerData} from './MetaHandler.js';\nimport {type TraceEventHandlerName,HandlerState} from './types.js';\n\nimport * as Platform from '../../../core/platform/platform.js';\nimport * as Helpers from '../helpers/helpers.js';\nimport * as Types from '../types/types.js';\n\n// Each thread contains events. Events indicate the thread and process IDs, which are\n// used to store the event in the correct process thread entry below.\nconst eventsInProcessThread =\n    new Map<Types.TraceEvents.ProcessID, Map<Types.TraceEvents.ThreadID, Types.TraceEvents.TraceEventSnapshot[]>>();\n\n// these types are wrong\nlet relevantEvts: Types.TraceEvents.TraceEventSnapshot[] = [];\nconst gpuEvents: Types.TraceEvents.TraceEventSnapshot[] = [];\nconst asyncEvts: Types.TraceEvents.TraceEventSnapshot[] = [];\nlet syntheticEvents: Types.TraceEvents.TraceEventSyntheticNestableAsyncEvent[] = [];\nconst waterFallEvents: Types.TraceEvents.TraceEventSnapshot[] = [];\nlet eventLatencyIdToFrameSeq: Record<string, string> = {};\n// export interface UberFramesData {\n//   relevantEvts: readonly Types.TraceEvents.TraceEventData[],\n//   syntheticEvents: readonly Types.TraceEvents.TraceEventSyntheticNestableAsyncEvent[];\n// }\n\nexport type UberFramesData = {\n  nonWaterfallEvts: readonly Types.TraceEvents.TraceEventData[],\n  waterFallEvts: readonly Types.TraceEvents.TraceEventData[],\n  eventLatencyIdToFrameSeq: Record<string, string>,\n};\n\nexport function reset(): void {\n  eventsInProcessThread.clear();\n  relevantEvts.length = 0;\n  gpuEvents.length = 0;\n  syntheticEvents.length = 0;\n  asyncEvts.length = 0;\n  waterFallEvents.length = 0;\n  eventLatencyIdToFrameSeq = {};\n  handlerState = HandlerState.INITIALIZED;\n}\n\nlet handlerState = HandlerState.UNINITIALIZED;\n\nconst someStuff  = {\n  CompositeLayers : 'CompositeLayers',\n  RasterTask : 'RasterTask',\n  ImageDecodeTask : 'ImageDecodeTask',\n  ImageUploadTask : 'ImageUploadTask',\n  DecodeImage : 'Decode Image',\n  ResizeImage : 'Resize Image',\n  DrawLazyPixelRef : 'Draw LazyPixelRef',\n  DecodeLazyPixelRef : 'Decode LazyPixelRef',\n\n  BeginFrame: 'BeginFrame',\n  RequestMainThreadFrame: 'RequestMainThreadFrame',\n  NeedsBeginFrameChanged: 'NeedsBeginFrameChanged',\n  BeginMainThreadFrame: 'BeginMainThreadFrame',\n  ActivateLayerTree: 'ActivateLayerTree',\n  DrawFrame: 'DrawFrame',\n  DroppedFrame: 'DroppedFrame',\n};\nconst someRelevantTraceEventTypes = [\n\n  ... Object.values(someStuff),\n\n  // timeline frame model\n  'ActivateLayerTree',\n  'BeginFrame',\n  'BeginMainThreadFrame,',\n  'CompositeLayers',\n  'Commit',\n  'DrawFrame',\n  'DroppedFrame',\n  'InvalidateLayout,',\n  'LayerTreeHostImplSnapshot',\n  'NeedsBeginFrameChanged',\n  'Paint',\n  'RequestMainThreadFrame',\n  'ScheduleStyleRecalculation,',\n  'ScrollLayer,',\n  'SetLayerTreeId',\n\n\n  'MainFrame.NotifyReadyToCommitOnImpl',\n  'MainFrame.CommitComplete',\n  'RasterizerTaskImpl::RunOnWorkerThread',\n  'LayerTreeHostImpl::FinishCommit',\n  'TileManager::FlushAndIssueSignals',\n  'ProxyImpl::ScheduledActionDraw',\n\n  // LONG ones and ones i typically comment out\n  'PipelineReporter',\n  'SendBeginMainFrameToCommit',\n  'BeginImplFrameToSendBeginMainFrame', // happens too much on dropped frames\n  'SubmitCompositorFrameToPresentationCompositorFrame', // parent phase in eventlatency\n  // 'Graphics.Pipeline',\n\n  'RasterDecoderImpl::DoEndRasterCHROMIUM',\n  'Frame',\n\n  // these are all pipeline reporter subitems. HOEVER they are also included in the eventlatency children too.\n  'Activation',\n  'BeginImplFrameToSendBeginMainFrame',\n  'Commit',\n  'EndActivateToSubmitCompositorFrame',\n  'EndCommitToActivation',\n  'ReceiveCompositorFrameToStartDraw',\n  'SendBeginMainFrameToCommit',\n  'StartDrawToSwapStart',\n  'SubmitCompositorFrameToPresentationCompositorFrame',\n  'SubmitToReceiveCompositorFrame',\n  'Swap',\n\n  'BeginFrame',\n  'DroppedFrame',\n  'RequestMainFrame',\n  'BeginMainThreadFrame',\n  'CompositeLayer',\n  'Commit',\n  'ActivateLayerTree',\n  'DrawFrame',\n\n  'EndCommitToActivation',\n  'Swap',\n  'SwapBuffers', // the gpu one\n  'Scheduler::BeginFrame',\n  'DisplayScheduler::BeginFrame',\n  'Scheduler::BeginImplFrame',\n\n  'EventLatency', // mocny said these are complicated. but.. they're also great.\n  // https://docs.google.com/spreadsheets/d/1F6BPrtIMgDD4eKH-VxEqzZy8dOeh3U2EZaYjVlIv-Hk/edit?resourcekey=0-UtBlkaCsd0Oi1Z3bQqHqow#gid=557410449\n  // TODO.. some of these are emitted separately on different trace categories.. so there's duplicates. ugh\n'GenerationToBrowserMain',\n'BrowserMainToRendererCompositor',\n'RendererCompositorQueueingDelay',\n'RendererCompositorProcessing',\n'RendererCompositorFinishedToEndActivate',\n'RendererCompositorFinishedToSendBeginMainFrame',\n'RendererCompositorFinishedToBeginImplFrame',\n'BeginImplFrameToSendBeginMainFrame',\n'RendererCompositorFinishedToCommit',\n'RendererCompositorFinishedToEndCommit',\n'RendererCompositorFinishedToActivation',\n'RendererCompositorFinishedToSubmitCompositorFrame',\n'RendererCompositorToMain',\n'RendererMainProcessing',\n'RendererMainFinishedToBeginImplFrame',\n'RendererMainFinishedToSendBeginMainFrame',\n'RendererMainFinishedToCommit',\n'RendererMainFinishedToEndCommit',\n'RendererMainFinishedToActivation',\n'RendererMainFinishedToEndActivate',\n'RendererMainFinishedToSubmitCompositorFrame',\n'SendBeginMainFrameToCommit',\n'Commit',\n'EndCommitToActivation',\n'Activation',\n'EndActivateToSubmitCompositorFrame',\n'SubmitCompositorFrameToPresentationCompositorFrame',\n'SubmitCompositorFrameToPresentationCompositorFrame sub-stages:',\n'SubmitToReceiveCompositorFrame',\n'ReceiveCompositorFrameToStartDraw',\n'StartDrawToSwapStart',\n'Swap',\n'SwapStartToBufferAvailable',\n'BufferAvailableToBufferReady',\n'BufferReadyToLatch',\n'LatchToSwapEnd',\n'SwapEndToPresentationCompositorFrame',\n\n  //\n  'EventTiming',\n\n  // my loaf branch\n  'LongAnimationFrame-pi',\n  'LongAnimationFrame-pi2',\n  'LongAnimationFrame-no2',\n  // 'LongAnimationFrame-no',\n  // 'LongAnimationFrame-nopi',\n  'LongAnimationFrame',\n  'LoAF-renderStart',\n  'LoAF-desiredRenderStart',\n  'LoAF-styleAndLayoutStart',\n\n  'ScreenshotMeta',\n];\n\nexport const eventLatencyBreakdownTypeNames = [\n'GenerationToBrowserMain',\n'BrowserMainToRendererCompositor',\n'RendererCompositorQueueingDelay',\n'RendererCompositorProcessing',\n'RendererCompositorFinishedToEndActivate',\n'RendererCompositorFinishedToSendBeginMainFrame',\n'RendererCompositorFinishedToBeginImplFrame',\n'BeginImplFrameToSendBeginMainFrame',\n'RendererCompositorFinishedToCommit',\n'RendererCompositorFinishedToEndCommit',\n'RendererCompositorFinishedToActivation',\n'RendererCompositorFinishedToSubmitCompositorFrame',\n\n'RendererCompositorToMain',\n'RendererMainProcessing',\n'RendererMainFinishedToBeginImplFrame',\n'RendererMainFinishedToSendBeginMainFrame',\n'RendererMainFinishedToCommit',\n'RendererMainFinishedToEndCommit',\n'RendererMainFinishedToActivation',\n'RendererMainFinishedToEndActivate',\n'RendererMainFinishedToSubmitCompositorFrame',\n\n'SendBeginMainFrameToCommit',\n'Commit',\n'EndCommitToActivation',\n'Activation',\n'EndActivateToSubmitCompositorFrame',\n\n// 'SubmitCompositorFrameToPresentationCompositorFrame', // parent phase that can overlap\n'SubmitToReceiveCompositorFrame',\n'ReceiveCompositorFrameToStartDraw',\n'StartDrawToSwapStart',\n'Swap',\n'SwapStartToBufferAvailable',\n'BufferAvailableToBufferReady',\n'BufferReadyToLatch',\n'LatchToSwapEnd',\n'SwapEndToPresentationCompositorFrame',\n];\n\nexport const waterfallTypes = new Map([\n  ['EventLatency', 4],\n  ['SendBeginMainFrameToCommit', 3],\n  ['EndCommitToActivation', 2],\n  ['Activation', 2],\n  ['EndActivateToSubmitCompositorFrame', 2],\n  ['SubmitCompositorFrameToPresentationCompositorFrame', 2],\n]);\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n\n  if (Types.TraceEvents.isTraceEventGPUTask(event)) {\n    gpuEvents.push(event);\n    Helpers.Trace.addEventToProcessThread(event, eventsInProcessThread);\n  } else if (\n    event.name === 'Screenshot'\n    // || event.cat === 'blink.user_timing'\n    || someRelevantTraceEventTypes.some(type => event.name === type)\n  ) {\n    if (event.ph === 'b' || event.ph === 'e') {\n      asyncEvts.push(event);\n    } else {\n\n      if (eventLatencyBreakdownTypeNames.includes(event.name)) {\n        // we have two diff events named Commit, we'll exclude the normal mainthread one.\n        if (event.name === 'Commit' && !event.cat.includes('cc')) {\n\n        } else {\n          waterFallEvents.push(event);\n        }\n      }\n      relevantEvts.push(event);\n    }\n    Helpers.Trace.addEventToProcessThread(event, eventsInProcessThread);\n  }\n\n}\n\nexport async function finalize(): Promise<void> {\n  const {browserProcessId, browserThreadId} = metaHandlerData();\n  const browserThreads = eventsInProcessThread.get(browserProcessId);\n  // if (browserThreads) {\n  //   relevantEvts = browserThreads.get(browserThreadId) || [];\n  // }\n\n  // TODO: somehow exclude PipelineReporter events that are perfectly nested. (end ts's are often identical in these cases.)\n\n  const {gpuProcessId, gpuThreadId, topLevelRendererIds} = metaHandlerData();\n  // This cuts down GPU Task count .. 33% of what ift was.\n  const ourRendererGPUTasks = gpuEvents.filter(e => topLevelRendererIds.has(e.args.data.renderer_pid));\n  relevantEvts = [... relevantEvts, ... ourRendererGPUTasks];\n\n  if (handlerState !== HandlerState.INITIALIZED) {\n    throw new Error('UberFrames handler is not initialized');\n  }\n\n  const matchedEvents: Map<string, {\n    begin: Types.TraceEvents.TraceEventNestableAsyncBegin | null,\n    end: Types.TraceEvents.TraceEventNestableAsyncEnd | null,\n  }> = new Map();\n\n  for (const event of [...asyncEvts]) {\n    const id = Helpers.Trace.extractId(event);\n    if (id === undefined) {\n      continue;\n    }\n    // Create a synthetic id to prevent collisions across categories.\n    // Console timings can be dispatched with the same id, so use the\n    // event name as well to generate unique ids.\n    const syntheticId = `${event.cat}:${id}:${event.name}`;\n    const otherEventsWithID = Platform.MapUtilities.getWithDefault(matchedEvents, syntheticId, () => {\n      return {begin: null, end: null};\n    });\n    const isStartEvent = event.ph === Types.TraceEvents.Phase.ASYNC_NESTABLE_START;\n    const isEndEvent = event.ph === Types.TraceEvents.Phase.ASYNC_NESTABLE_END;\n\n    if (isStartEvent) {\n      otherEventsWithID.begin = event;\n    } else if (isEndEvent) {\n      otherEventsWithID.end = event;\n    }\n  }\n\n  for (const [id, eventsPair] of matchedEvents.entries()) {\n    if (!eventsPair.begin || !eventsPair.end) {\n      // This should never happen, the backend only creates the events once it\n      // has them both, so we should never get into this state.\n      // If we do, something is very wrong, so let's just drop that problematic event.\n      continue;\n    }\n\n    const event: Types.TraceEvents.TraceEventSyntheticNestableAsyncEvent = {\n      cat: eventsPair.end.cat,\n      ph: 'X',\n      pid: eventsPair.end.pid,\n      tid: eventsPair.end.tid,\n      id,\n      // Both events have the same name, so it doesn't matter which we pick to\n      // use as the description\n      name: eventsPair.begin.name,\n      dur: Types.Timing.MicroSeconds(eventsPair.end.ts - eventsPair.begin.ts),\n      ts: eventsPair.begin.ts,\n      args: {\n        data: {\n          beginEvent: eventsPair.begin,\n          endEvent: eventsPair.end,\n        },\n      },\n    };\n\n    // still I do see some 0's in the real trace. i messed up the c++ side.\n    if (event.name === 'EventLatency') {\n      eventLatencyIdToFrameSeq[eventsPair.begin.id2.local] = eventsPair.begin.args.event_latency.frame_sequence ?? null;\n    }\n    if (event.name === 'PipelineReporter') {\n      eventLatencyIdToFrameSeq[eventsPair.begin.id2.local] = eventsPair.begin.args.chrome_frame_reporter.frame_sequence ?? null;\n    }\n\n    const existingDuplicate = syntheticEvents.find(e => {\n      return e.name === event.name &&\n      e.ts === event.ts &&\n      e.dur === event.dur &&\n      e.id2?.local === event.id2?.local &&\n      e.tid === event.tid &&\n      e.pid === event.pid;\n    });\n    // Some eventlatnecy evts are emitted on multiple categories separtely. leave them otu\n    if (existingDuplicate) {continue;}\n\n    if (eventLatencyBreakdownTypeNames.includes(event.name)) {\n      waterFallEvents.push(event);\n    }\n    syntheticEvents.push(event);\n  }\n  // drop pipelinereporter that werent presented. or browser process.\n  // TODO: do this earlier? iunno\n  // EDIT: disabled filtering since ubeframes is a mess anyway.\n  syntheticEvents = syntheticEvents.filter(e => {\n    return true;\n    if (e.name !== 'PipelineReporter') {return true;}\n    return topLevelRendererIds.has(e.pid) &&\n      e.args.data.beginEvent.args.chrome_frame_reporter.frame_type !== 'FORKED' &&\n      e.args.data.beginEvent.args.chrome_frame_reporter.state === 'STATE_PRESENTED_ALL';\n  });\n\n  handlerState = HandlerState.FINALIZED;\n}\n\n// TODO: is it okay to do work here? this is only called once? (or should i put the _work_ in finalize)\n// so far looks like its only called once, so whatev.\nexport function data(): UberFramesData {\n  if (handlerState !== HandlerState.FINALIZED) {\n    throw new Error('UberFrames handler is not finalized');\n  }\n  return {\n    nonWaterfallEvts: [...relevantEvts, ...syntheticEvents].sort((event1, event2) => event1.ts - event2.ts),\n    waterFallEvts: [...waterFallEvents].sort((event1, event2) => event1.ts - event2.ts),\n    eventLatencyIdToFrameSeq,\n  };\n}\n\nexport function deps(): TraceEventHandlerName[] {\n  return ['Meta'];\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/models/trace/handlers/UserInteractionsHandler.js

@@ -0,0 +1,168 @@
+import * as Helpers from "../helpers/helpers.js";
+import * as Types from "../types/types.js";
+import { HandlerState } from "./types.js";
+const allEvents = [];
+export const LONG_INTERACTION_THRESHOLD = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(200));
+let longestInteractionEvent = null;
+const interactionEvents = [];
+const interactionEventsWithNoNesting = [];
+const eventTimingEndEventsById = /* @__PURE__ */ new Map();
+const eventTimingStartEventsForInteractions = [];
+let handlerState = HandlerState.UNINITIALIZED;
+export function reset() {
+  allEvents.length = 0;
+  interactionEvents.length = 0;
+  eventTimingStartEventsForInteractions.length = 0;
+  eventTimingEndEventsById.clear();
+  interactionEventsWithNoNesting.length = 0;
+  longestInteractionEvent = null;
+  handlerState = HandlerState.INITIALIZED;
+}
+export function handleEvent(event) {
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("Handler is not initialized");
+  }
+  if (!Types.TraceEvents.isTraceEventEventTiming(event)) {
+    return;
+  }
+  if (Types.TraceEvents.isTraceEventEventTimingEnd(event)) {
+    eventTimingEndEventsById.set(event.id, event);
+  }
+  allEvents.push(event);
+  if (!event.args.data || !Types.TraceEvents.isTraceEventEventTimingStart(event)) {
+    return;
+  }
+  const { duration, interactionId } = event.args.data;
+  if (duration < 1 || interactionId === void 0 || interactionId === 0) {
+    return;
+  }
+  eventTimingStartEventsForInteractions.push(event);
+}
+const pointerEventTypes = /* @__PURE__ */ new Set([
+  "pointerdown",
+  "touchstart",
+  "pointerup",
+  "touchend",
+  "mousedown",
+  "mouseup",
+  "click"
+]);
+const keyboardEventTypes = /* @__PURE__ */ new Set([
+  "keydown",
+  "keypress",
+  "keyup"
+]);
+export function categoryOfInteraction(interaction) {
+  if (pointerEventTypes.has(interaction.type)) {
+    return "POINTER";
+  }
+  if (keyboardEventTypes.has(interaction.type)) {
+    return "KEYBOARD";
+  }
+  return "OTHER";
+}
+export function removeNestedInteractions(interactions) {
+  const earliestEventForEndTimePerCategory = {
+    POINTER: /* @__PURE__ */ new Map(),
+    KEYBOARD: /* @__PURE__ */ new Map(),
+    OTHER: /* @__PURE__ */ new Map()
+  };
+  function storeEventIfEarliestForCategoryAndEndTime(interaction) {
+    const category = categoryOfInteraction(interaction);
+    const earliestEventForEndTime = earliestEventForEndTimePerCategory[category];
+    const endTime = Types.Timing.MicroSeconds(interaction.ts + interaction.dur);
+    const earliestCurrentEvent = earliestEventForEndTime.get(endTime);
+    if (!earliestCurrentEvent) {
+      earliestEventForEndTime.set(endTime, interaction);
+      return;
+    }
+    if (interaction.ts < earliestCurrentEvent.ts) {
+      earliestEventForEndTime.set(endTime, interaction);
+    } else if (interaction.ts === earliestCurrentEvent.ts && interaction.interactionId === earliestCurrentEvent.interactionId) {
+      const currentEventProcessingTime = earliestCurrentEvent.processingEnd - earliestCurrentEvent.processingStart;
+      const newEventProcessingTime = interaction.processingEnd - interaction.processingStart;
+      if (newEventProcessingTime > currentEventProcessingTime) {
+        earliestEventForEndTime.set(endTime, interaction);
+      }
+    }
+    if (interaction.processingStart < earliestCurrentEvent.processingStart) {
+      earliestCurrentEvent.processingStart = interaction.processingStart;
+      writeSyntheticTimespans(earliestCurrentEvent);
+    }
+    if (interaction.processingEnd > earliestCurrentEvent.processingEnd) {
+      earliestCurrentEvent.processingEnd = interaction.processingEnd;
+      writeSyntheticTimespans(earliestCurrentEvent);
+    }
+  }
+  for (const interaction of interactions) {
+    storeEventIfEarliestForCategoryAndEndTime(interaction);
+  }
+  const keptEvents = Object.values(earliestEventForEndTimePerCategory).flatMap((eventsByEndTime) => Array.from(eventsByEndTime.values()));
+  keptEvents.sort((eventA, eventB) => {
+    return eventA.ts - eventB.ts;
+  });
+  return keptEvents;
+}
+function writeSyntheticTimespans(event) {
+  const startEvent = event.args.data.beginEvent;
+  const endEvent = event.args.data.endEvent;
+  event.inputDelay = Types.Timing.MicroSeconds(event.processingStart - startEvent.ts);
+  event.mainThreadHandling = Types.Timing.MicroSeconds(event.processingEnd - event.processingStart);
+  event.presentationDelay = Types.Timing.MicroSeconds(endEvent.ts - event.processingEnd);
+}
+export async function finalize() {
+  for (const interactionStartEvent of eventTimingStartEventsForInteractions) {
+    const endEvent = eventTimingEndEventsById.get(interactionStartEvent.id);
+    if (!endEvent) {
+      continue;
+    }
+    if (!interactionStartEvent.args.data?.type || !interactionStartEvent.args.data?.interactionId) {
+      continue;
+    }
+    const processingStartRelativeToTraceTime = Types.Timing.MicroSeconds(Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.processingStart) - Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.timeStamp) + interactionStartEvent.ts);
+    const processingEndRelativeToTraceTime = Types.Timing.MicroSeconds(Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.processingEnd) - Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.timeStamp) + interactionStartEvent.ts);
+    const interactionEvent = {
+      cat: interactionStartEvent.cat,
+      name: interactionStartEvent.name,
+      pid: interactionStartEvent.pid,
+      tid: interactionStartEvent.tid,
+      ph: interactionStartEvent.ph,
+      processingStart: processingStartRelativeToTraceTime,
+      processingEnd: processingEndRelativeToTraceTime,
+      inputDelay: Types.Timing.MicroSeconds(-1),
+      mainThreadHandling: Types.Timing.MicroSeconds(-1),
+      presentationDelay: Types.Timing.MicroSeconds(-1),
+      args: {
+        data: {
+          beginEvent: interactionStartEvent,
+          endEvent
+        }
+      },
+      ts: interactionStartEvent.ts,
+      dur: Types.Timing.MicroSeconds(endEvent.ts - interactionStartEvent.ts),
+      type: interactionStartEvent.args.data.type,
+      interactionId: interactionStartEvent.args.data.interactionId
+    };
+    writeSyntheticTimespans(interactionEvent);
+    interactionEvents.push(interactionEvent);
+  }
+  handlerState = HandlerState.FINALIZED;
+  interactionEventsWithNoNesting.push(...removeNestedInteractions(interactionEvents));
+  for (const interactionEvent of interactionEventsWithNoNesting) {
+    if (!longestInteractionEvent || longestInteractionEvent.dur < interactionEvent.dur) {
+      longestInteractionEvent = interactionEvent;
+    }
+  }
+}
+export function data() {
+  return {
+    allEvents: [...allEvents],
+    interactionEvents: [...interactionEvents],
+    interactionEventsWithNoNesting: [...interactionEventsWithNoNesting],
+    longestInteractionEvent,
+    interactionsOverThreshold: new Set(interactionEvents.filter((event) => {
+      return event.dur > LONG_INTERACTION_THRESHOLD;
+    }))
+  };
+}
+//# sourceMappingURL=UserInteractionsHandler.js.map

package/models/trace/handlers/UserInteractionsHandler.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../front_end/models/trace/handlers/UserInteractionsHandler.ts"],
+  "sourcesContent": ["// Copyright 2022 The Chromium Authors. All rights reserved.\n// Use of this source code is governed by a BSD-style license that can be\n// found in the LICENSE file.\n\nimport * as Helpers from '../helpers/helpers.js';\nimport * as Types from '../types/types.js';\n\nimport {HandlerState} from './types.js';\n\n// This handler serves two purposes. It generates a list of events that are\n// used to show user clicks in the timeline. It is also used to gather\n// EventTimings into Interactions, which we use to show interactions and\n// highlight long interactions to the user, along with INP.\n\n// We don't need to know which process / thread these events occurred in,\n// because they are effectively global, so we just track all that we find.\nconst allEvents: Types.TraceEvents.TraceEventEventTiming[] = [];\n\nexport const LONG_INTERACTION_THRESHOLD = Helpers.Timing.millisecondsToMicroseconds(Types.Timing.MilliSeconds(200));\n\nexport interface UserInteractionsData {\n  /** All the user events we found in the trace */\n  allEvents: readonly Types.TraceEvents.TraceEventEventTiming[];\n  /** All the interaction events we found in the trace that had an\n   * interactionId and a duration > 0\n   **/\n  interactionEvents: readonly Types.TraceEvents.SyntheticInteractionPair[];\n  /** If the user rapidly generates interaction events (think typing into a\n   * text box), in the UI we only really want to show the user the longest\n   * interaction in that set.\n   * For example picture interactions like this:\n   * ===[interaction A]==========\n   *       =[interaction B]======\n   *            =[interaction C]=\n   *\n   * These events all end at the same time, and so in this instance we only want\n   * to show the first interaction A on the timeline, as that is the longest one\n   * and the one the developer should be focusing on. So this array of events is\n   * all the interaction events filtered down, removing any nested interactions\n   * entirely.\n   **/\n  interactionEventsWithNoNesting: readonly Types.TraceEvents.SyntheticInteractionPair[];\n  // The longest duration interaction event. Can be null if the trace has no interaction events.\n  longestInteractionEvent: Readonly<Types.TraceEvents.SyntheticInteractionPair>|null;\n  // All interactions that went over the interaction threshold (200ms, see https://web.dev/inp/)\n  interactionsOverThreshold: Readonly<Set<Types.TraceEvents.SyntheticInteractionPair>>;\n}\n\nlet longestInteractionEvent: Types.TraceEvents.SyntheticInteractionPair|null = null;\n\nconst interactionEvents: Types.TraceEvents.SyntheticInteractionPair[] = [];\nconst interactionEventsWithNoNesting: Types.TraceEvents.SyntheticInteractionPair[] = [];\nconst eventTimingEndEventsById = new Map<string, Types.TraceEvents.TraceEventEventTimingEnd>();\nconst eventTimingStartEventsForInteractions: Types.TraceEvents.TraceEventEventTimingBegin[] = [];\nlet handlerState = HandlerState.UNINITIALIZED;\n\nexport function reset(): void {\n  allEvents.length = 0;\n  interactionEvents.length = 0;\n  eventTimingStartEventsForInteractions.length = 0;\n  eventTimingEndEventsById.clear();\n  interactionEventsWithNoNesting.length = 0;\n  longestInteractionEvent = null;\n  handlerState = HandlerState.INITIALIZED;\n}\n\nexport function handleEvent(event: Types.TraceEvents.TraceEventData): void {\n  if (handlerState !== HandlerState.INITIALIZED) {\n    throw new Error('Handler is not initialized');\n  }\n\n  if (!Types.TraceEvents.isTraceEventEventTiming(event)) {\n    return;\n  }\n\n  if (Types.TraceEvents.isTraceEventEventTimingEnd(event)) {\n    // Store the end event; for each start event that is an interaction, we need the matching end event to calculate the duration correctly.\n    eventTimingEndEventsById.set(event.id, event);\n  }\n\n  allEvents.push(event);\n\n  // From this point on we want to find events that represent interactions.\n  // These events are always start events - those are the ones that contain all\n  // the metadata about the interaction.\n  if (!event.args.data || !Types.TraceEvents.isTraceEventEventTimingStart(event)) {\n    return;\n  }\n  const {duration, interactionId} = event.args.data;\n  // We exclude events for the sake of interactions if:\n  // 1. They have no duration.\n  // 2. They have no interactionId\n  // 3. They have an interactionId of 0: this indicates that it's not an\n  //    interaction that we care about because it hasn't had its own interactionId\n  //    set (0 is the default on the backend).\n  // See: https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/timing/responsiveness_metrics.cc;l=133;drc=40c209a9c365ebb9f16fb99dfe78c7fe768b9594\n\n  if (duration < 1 || interactionId === undefined || interactionId === 0) {\n    return;\n  }\n\n  // Store the start event. In the finalize() function we will pair this with\n  // its end event and create the synthetic interaction event.\n  eventTimingStartEventsForInteractions.push(event);\n}\n\n/**\n * See https://web.dev/better-responsiveness-metric/#interaction-types for the\n * table that defines these sets.\n **/\nconst pointerEventTypes = new Set([\n  'pointerdown',\n  'touchstart',\n  'pointerup',\n  'touchend',\n  'mousedown',\n  'mouseup',\n  'click',\n]);\n\nconst keyboardEventTypes = new Set([\n  'keydown',\n  'keypress',\n  'keyup',\n]);\n\nexport type InteractionCategory = 'KEYBOARD'|'POINTER'|'OTHER';\nexport function categoryOfInteraction(interaction: Types.TraceEvents.SyntheticInteractionPair): InteractionCategory {\n  if (pointerEventTypes.has(interaction.type)) {\n    return 'POINTER';\n  }\n  if (keyboardEventTypes.has(interaction.type)) {\n    return 'KEYBOARD';\n  }\n\n  return 'OTHER';\n}\n\n/**\n * We define a set of interactions as nested where:\n * 1. Their end times align.\n * 2. The longest interaction's start time is earlier than all other\n * interactions with the same end time.\n * 3. The interactions are of the same category [each interaction is either\n * categorised as keyboard, or pointer.]\n *\n * =============A=[pointerup]=\n *        ====B=[pointerdown]=\n *        ===C=[pointerdown]==\n *         ===D=[pointerup]===\n *\n * In this example, B, C and D are all nested and therefore should not be\n * returned from this function.\n *\n * However, in this example we would only consider B nested (under A) and D\n * nested (under C). A and C both stay because they are of different types.\n * ========A=[keydown]====\n *   =======B=[keyup]=====\n *    ====C=[pointerdown]=\n *         =D=[pointerup]=\n **/\nexport function removeNestedInteractions(interactions: readonly Types.TraceEvents.SyntheticInteractionPair[]):\n    readonly Types.TraceEvents.SyntheticInteractionPair[] {\n  /**\n   * Because we nest events only that are in the same category, we store the\n   * longest event for a given end time by category.\n   **/\n  const earliestEventForEndTimePerCategory:\n      Record<InteractionCategory, Map<Types.Timing.MicroSeconds, Types.TraceEvents.SyntheticInteractionPair>> = {\n        POINTER: new Map(),\n        KEYBOARD: new Map(),\n        OTHER: new Map(),\n      };\n\n  function storeEventIfEarliestForCategoryAndEndTime(interaction: Types.TraceEvents.SyntheticInteractionPair): void {\n    const category = categoryOfInteraction(interaction);\n    const earliestEventForEndTime = earliestEventForEndTimePerCategory[category];\n    const endTime = Types.Timing.MicroSeconds(interaction.ts + interaction.dur);\n\n    const earliestCurrentEvent = earliestEventForEndTime.get(endTime);\n    if (!earliestCurrentEvent) {\n      earliestEventForEndTime.set(endTime, interaction);\n      return;\n    }\n    if (interaction.ts < earliestCurrentEvent.ts) {\n      earliestEventForEndTime.set(endTime, interaction);\n    } else if (\n        interaction.ts === earliestCurrentEvent.ts &&\n        interaction.interactionId === earliestCurrentEvent.interactionId) {\n      // We have seen in traces that the same interaction can have multiple\n      // events (e.g. a 'click' and a 'pointerdown'). Often only one of these\n      // events will have an event handler bound to it which caused delay on\n      // the main thread, and the others will not. This leads to a situation\n      // where if we pick one of the events that had no event handler, its\n      // processing time (processingEnd - processingStart) will be 0, but if we\n      // had picked the event that had the slow event handler, we would show\n      // correctly the main thread delay due to the event handler.\n      // So, if we find events with the same interactionId and the same\n      // begin/end times, we pick the one with the largest (processingEnd -\n      // processingStart) time in order to make sure we find the event with the\n      // worst main thread delay, as that is the one the user should care\n      // about.\n      const currentEventProcessingTime = earliestCurrentEvent.processingEnd - earliestCurrentEvent.processingStart;\n      const newEventProcessingTime = interaction.processingEnd - interaction.processingStart;\n\n      // Use the new interaction if it has a longer processing time than the existing one.\n      if (newEventProcessingTime > currentEventProcessingTime) {\n        earliestEventForEndTime.set(endTime, interaction);\n      }\n    }\n\n    // Maximize the processing time based on the \"children\" interactions.\n    // We pick the earliest start processing time, and the latest end\n    // processing time to avoid under-reporting.\n    if (interaction.processingStart < earliestCurrentEvent.processingStart) {\n      earliestCurrentEvent.processingStart = interaction.processingStart;\n      writeSyntheticTimespans(earliestCurrentEvent);\n    }\n    if (interaction.processingEnd > earliestCurrentEvent.processingEnd) {\n      earliestCurrentEvent.processingEnd = interaction.processingEnd;\n      writeSyntheticTimespans(earliestCurrentEvent);\n    }\n  }\n\n  for (const interaction of interactions) {\n    storeEventIfEarliestForCategoryAndEndTime(interaction);\n  }\n\n  // Combine all the events that we have kept from all the per-category event\n  // maps back into an array and sort them by timestamp.\n  const keptEvents = Object.values(earliestEventForEndTimePerCategory)\n                         .flatMap(eventsByEndTime => Array.from(eventsByEndTime.values()));\n  keptEvents.sort((eventA, eventB) => {\n    return eventA.ts - eventB.ts;\n  });\n  return keptEvents;\n}\n\nfunction writeSyntheticTimespans(event: Types.TraceEvents.SyntheticInteractionPair): void {\n  const startEvent = event.args.data.beginEvent;\n  const endEvent = event.args.data.endEvent;\n\n  event.inputDelay = Types.Timing.MicroSeconds(event.processingStart - startEvent.ts);\n  event.mainThreadHandling = Types.Timing.MicroSeconds(event.processingEnd - event.processingStart);\n  event.presentationDelay = Types.Timing.MicroSeconds(endEvent.ts - event.processingEnd);\n}\n\nexport async function finalize(): Promise<void> {\n  // For each interaction start event, find the async end event by the ID, and then create the Synthetic Interaction event.\n  for (const interactionStartEvent of eventTimingStartEventsForInteractions) {\n    const endEvent = eventTimingEndEventsById.get(interactionStartEvent.id);\n    if (!endEvent) {\n      // If we cannot find an end event, bail and drop this event.\n      continue;\n    }\n    if (!interactionStartEvent.args.data?.type || !interactionStartEvent.args.data?.interactionId) {\n      // A valid interaction event that we care about has to have a type (e.g.\n      // pointerdown, keyup).\n      //\n      // We also need to ensure it has an interactionId. We already checked\n      // this in the handleEvent() function, but we do it here also to satisfy\n      // TypeScript.\n      continue;\n    }\n\n    // In the future we will add microsecond timestamps to the trace events,\n    // but until then we can use the millisecond precision values that are in\n    // the trace event. To adjust them to be relative to the event.ts and the\n    // trace timestamps, for both processingStart and processingEnd we subtract\n    // the event timestamp (NOT event.ts, but the timeStamp millisecond value\n    // emitted in args.data), and then add that value to the event.ts. This\n    // will give us a processingStart and processingEnd time in microseconds\n    // that is relative to event.ts, and can be used when drawing boxes.\n    // There is some inaccuracy here as we are converting milliseconds to microseconds, but it is good enough until the backend emits more accurate numbers.\n    const processingStartRelativeToTraceTime = Types.Timing.MicroSeconds(\n        Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.processingStart) -\n            Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.timeStamp) +\n            interactionStartEvent.ts,\n    );\n\n    const processingEndRelativeToTraceTime = Types.Timing.MicroSeconds(\n        (Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.processingEnd) -\n         Helpers.Timing.millisecondsToMicroseconds(interactionStartEvent.args.data.timeStamp)) +\n        interactionStartEvent.ts);\n\n    const interactionEvent: Types.TraceEvents.SyntheticInteractionPair = {\n      // Use the start event to define the common fields.\n      cat: interactionStartEvent.cat,\n      name: interactionStartEvent.name,\n      pid: interactionStartEvent.pid,\n      tid: interactionStartEvent.tid,\n      ph: interactionStartEvent.ph,\n      processingStart: processingStartRelativeToTraceTime,\n      processingEnd: processingEndRelativeToTraceTime,\n      // These will be set in writeSyntheticTimespans()\n      inputDelay: Types.Timing.MicroSeconds(-1),\n      mainThreadHandling: Types.Timing.MicroSeconds(-1),\n      presentationDelay: Types.Timing.MicroSeconds(-1),\n      args: {\n        data: {\n          beginEvent: interactionStartEvent,\n          endEvent: endEvent,\n        },\n      },\n      ts: interactionStartEvent.ts,\n      dur: Types.Timing.MicroSeconds(endEvent.ts - interactionStartEvent.ts),\n      type: interactionStartEvent.args.data.type,\n      interactionId: interactionStartEvent.args.data.interactionId,\n    };\n    writeSyntheticTimespans(interactionEvent);\n\n    interactionEvents.push(interactionEvent);\n  }\n\n  handlerState = HandlerState.FINALIZED;\n  interactionEventsWithNoNesting.push(...removeNestedInteractions(interactionEvents));\n\n  // Pick the longest interactions from the set that were not nested, as we\n  // know those are the set of the largest interactions.\n  for (const interactionEvent of interactionEventsWithNoNesting) {\n    if (!longestInteractionEvent || longestInteractionEvent.dur < interactionEvent.dur) {\n      longestInteractionEvent = interactionEvent;\n    }\n  }\n}\n\nexport function data(): UserInteractionsData {\n  return {\n    allEvents: [...allEvents],\n    interactionEvents: [...interactionEvents],\n    interactionEventsWithNoNesting: [...interactionEventsWithNoNesting],\n    longestInteractionEvent,\n    interactionsOverThreshold: new Set(interactionEvents.filter(event => {\n      return event.dur > LONG_INTERACTION_THRESHOLD;\n    })),\n  };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/models/trace/handlers/UserTimingsHandler.js

@@ -0,0 +1,97 @@
+import * as Helpers from "../helpers/helpers.js";
+import * as Types from "../types/types.js";
+import { HandlerState } from "./types.js";
+let syntheticEvents = [];
+const performanceMeasureEvents = [];
+const performanceMarkEvents = [];
+const consoleTimings = [];
+const timestampEvents = [];
+let handlerState = HandlerState.UNINITIALIZED;
+export function reset() {
+  syntheticEvents.length = 0;
+  performanceMeasureEvents.length = 0;
+  performanceMarkEvents.length = 0;
+  consoleTimings.length = 0;
+  timestampEvents.length = 0;
+  handlerState = HandlerState.INITIALIZED;
+}
+const resourceTimingNames = [
+  "workerStart",
+  "redirectStart",
+  "redirectEnd",
+  "fetchStart",
+  "domainLookupStart",
+  "domainLookupEnd",
+  "connectStart",
+  "connectEnd",
+  "secureConnectionStart",
+  "requestStart",
+  "responseStart",
+  "responseEnd"
+];
+const navTimingNames = [
+  "navigationStart",
+  "unloadEventStart",
+  "unloadEventEnd",
+  "redirectStart",
+  "redirectEnd",
+  "fetchStart",
+  "commitNavigationEnd",
+  "domainLookupStart",
+  "domainLookupEnd",
+  "connectStart",
+  "connectEnd",
+  "secureConnectionStart",
+  "requestStart",
+  "responseStart",
+  "responseEnd",
+  "domLoading",
+  "domInteractive",
+  "domContentLoadedEventStart",
+  "domContentLoadedEventEnd",
+  "domComplete",
+  "loadEventStart",
+  "loadEventEnd"
+];
+export function handleEvent(event) {
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("UserTimings handler is not initialized");
+  }
+  const ignoredNames = [...resourceTimingNames, ...navTimingNames];
+  if (ignoredNames.includes(event.name)) {
+    return;
+  }
+  if (Types.TraceEvents.isTraceEventPerformanceMeasure(event)) {
+    performanceMeasureEvents.push(event);
+    return;
+  }
+  if (Types.TraceEvents.isTraceEventPerformanceMark(event)) {
+    performanceMarkEvents.push(event);
+  }
+  if (Types.TraceEvents.isTraceEventConsoleTime(event)) {
+    consoleTimings.push(event);
+  }
+  if (Types.TraceEvents.isTraceEventTimeStamp(event)) {
+    timestampEvents.push(event);
+  }
+}
+export async function finalize() {
+  if (handlerState !== HandlerState.INITIALIZED) {
+    throw new Error("UserTimings handler is not initialized");
+  }
+  const asyncEvents = [...performanceMeasureEvents, ...consoleTimings];
+  syntheticEvents = Helpers.Trace.createMatchedSortedSyntheticEvents(asyncEvents);
+  handlerState = HandlerState.FINALIZED;
+}
+export function data() {
+  if (handlerState !== HandlerState.FINALIZED) {
+    throw new Error("UserTimings handler is not finalized");
+  }
+  return {
+    performanceMeasures: syntheticEvents.filter((e) => e.cat === "blink.user_timing"),
+    consoleTimings: syntheticEvents.filter((e) => e.cat === "blink.console"),
+    performanceMarks: [...performanceMarkEvents],
+    timestampEvents: [...timestampEvents]
+  };
+}
+//# sourceMappingURL=UserTimingsHandler.js.map