lighthouse 9.5.0-dev.20230123 → 9.5.0-dev.20230125

package/types/artifacts.d.ts

@@ -17,6 +17,7 @@ import type { TaskNode as _TaskNode } from '../core/lib/tracehouse/main-thread-t
 import AuditDetails from './lhr/audit-details.js'
 import Config from './config.js';
 import Gatherer from './gatherer.js';
+import {IEntity} from 'third-party-web';
 import {IcuMessage} from './lhr/i18n.js';
 import LHResult from './lhr/lhr.js'
 import Protocol from './protocol.js';
@@ -720,12 +721,16 @@ declare module Artifacts {
     frameEvents: Array<TraceEvent>;
     /** The subset of trace events from the main frame and any child frames, sorted by timestamp. */
     frameTreeEvents: Array<TraceEvent>;
-    /** IDs for the trace's main frame, process, and thread. */
-    mainFrameIds: {pid: number, tid: number, frameId: string};
+    /** IDs for the trace's main frame, and process. The startingPid is the initial process id, however cross-origin navigations may incur changes to the pid while the frame ID remains identical. */
+    mainFrameInfo: {startingPid: number, frameId: string};
     /** The list of frames committed in the trace. */
     frames: Array<{id: string, url: string}>;
     /** The trace event marking the time at which the run should consider to have begun. Typically the same as the navigationStart but might differ due to SPA navigations, client-side redirects, etc. In the FR timespan case, this event is injected by Lighthouse itself. */
     timeOriginEvt: TraceEvent;
+    /** All received trace events subsetted to important categories. */
+    _keyEvents: Array<TraceEvent>;
+    /** Map where keys are process IDs and their values are thread IDs */
+    _rendererPidToTid: Map<number, number>;
   }
 
   interface ProcessedNavigation {
@@ -925,6 +930,19 @@ declare module Artifacts {
     /** The MIME type of the underlying image file. */
     mimeType?: string;
   }
+
+  interface Entity extends IEntity {
+    isUnrecognized?: boolean;
+  }
+
+  interface EntityClassification {
+    urlsByEntity: Map<Entity, Set<string>>;
+    entityByUrl: Map<string, Entity>;
+    firstParty?: Entity;
+
+    // Convenience methods.
+    isFirstParty: (url: string) => boolean;
+  }
 }
 
 export interface Trace {
@@ -959,6 +977,7 @@ export interface TraceEvent {
     };
     data?: {
       frame?: string;
+      processId?: number;
       isLoadingMainFrame?: boolean;
       documentLoaderURL?: string;
       frames?: {

package/types/lhr/lhr.d.ts

@@ -56,6 +56,8 @@ interface Result {
   };
   /** An array containing the result of all stack packs. */
   stackPacks?: Result.StackPack[];
+  /** All the origins encountered during this Lighthouse run, and information about what web property (aka "entity") they belong to. Won't be present for snapshot mode. */
+  entities?: Result.Entities;
   /** Screenshot taken of the full page, with node rects referencing audit results. If there was an error with collection, this is null. If disabled via the disableFullPageScreenshot setting, this is undefined. */
   fullPageScreenshot?: Result.FullPageScreenshot | null;
 }
@@ -151,6 +153,37 @@ declare module Result {
     nodes: Record<string, AuditDetails.Rect>;
   }
 
+  /**
+   * Entity classification for the run, for resolving URLs/items to entities in report.
+   * The two lookup tables (LUT) below provide space-optimized, O(1) index lookup into entities.list.
+   */
+  interface Entities {
+    /** All entities (1st and 3rd party) discovered during the run */
+    list: Array<LhrEntity>;
+    /** Name of the first-party entity */
+    firstParty?: string;
+    /** Entity-name to entity index lookup table  */
+    entityIndexByName: Record<string, number>;
+    /** URL origin to entity index lookup table */
+    entityIndexByOrigin: Record<string, number>;
+  }
+
+  /**
+   * An entity that's either recognized by third-party-web or made up by Lighthouse.
+   */
+  interface LhrEntity {
+    /** Name of the entity. Maps to third-party-web unique name for recognized entities and a root domain name for the unrecognized. */
+    name: string;
+    /** Homepage URL for a recognized entity, if available in third-party-web. */
+    homepage?: string;
+    /** Category name that the entity belongs to, if available. */
+    category?: string;
+    /** Is this entity the first party? */
+    isFirstParty?: boolean;
+    /** Is this entity recognized by third-party-web? */
+    isUnrecognized?: boolean;
+  }
+
   /**
    * Info about an `LH.IcuMessage` value that was localized to a string when
    * included in the LHR. Value is either a

package/core/lib/minify-trace.d.ts

@@ -1,6 +0,0 @@
-/**
- * @param {LH.Trace} inputTrace
- * @return {LH.Trace}
- */
-export function minifyTrace(inputTrace: LH.Trace): LH.Trace;
-//# sourceMappingURL=minify-trace.d.ts.map

package/core/lib/minify-trace.js

@@ -1,172 +0,0 @@
-/**
- * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
- * 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.
- */
-
-/* eslint-disable no-console */
-
-/**
- * @fileoverview Minifies a trace by removing unnecessary events, throttling screenshots, etc.
- *  See the following files for necessary events:
- *    - core/computed/page-dependency-graph.js
- *    - core/lib/dependency-graph/cpu-node.js
- *    - core/lib/tracehouse/trace-processor.js
- */
-
-import {TraceProcessor} from './tracehouse/trace-processor.js';
-
-const toplevelTaskNames = new Set([
-  'RunTask', // m71+
-  'ThreadControllerImpl::RunTask', // m69-70
-  'ThreadControllerImpl::DoWork', // m66-68
-  'TaskQueueManager::ProcessTaskFromWorkQueue', // m65 and below
-]);
-
-const traceCategoriesToAlwaysKeep = new Set([
-  // Labels the threads correctly in DevTools Performance panel
-  '__metadata',
-]);
-
-const traceEventsToAlwaysKeep = new Set([
-  'Screenshot',
-  'TracingStartedInBrowser',
-  'TracingStartedInPage',
-  'navigationStart',
-  'ParseAuthorStyleSheet',
-  'ParseHTML',
-  'PlatformResourceSendRequest',
-  'ResourceSendRequest',
-  'ResourceReceiveResponse',
-  'ResourceFinish',
-  'ResourceReceivedData',
-  'EventDispatch',
-  'LayoutShift',
-  'FrameCommittedInBrowser',
-  'EventTiming',
-  'Responsiveness.Renderer.UserInteraction',
-  // Not currently used by Lighthouse but might be used in the future for cross-frame LCP
-  'NavStartToLargestContentfulPaint::Invalidate::AllFrames::UKM',
-  'NavStartToLargestContentfulPaint::Candidate::AllFrames::UKM',
-  // Needed for CPU profiler task attribution
-  'Profile',
-  'ProfileChunk',
-]);
-
-const traceEventsToKeepInToplevelTask = new Set([
-  // Needed for CPU node timing simulations
-  'Layout',
-  'RunMicrotasks',
-  // All of these are needed to create graph relationships
-  'TimerInstall',
-  'TimerFire',
-  'InvalidateLayout',
-  'ScheduleStyleRecalculation',
-  'EvaluateScript',
-  'XHRReadyStateChange',
-  'FunctionCall',
-  'v8.compile',
-  'ParseAuthorStyleSheet',
-  'ResourceSendRequest',
-]);
-
-const traceEventsToKeepInProcess = new Set([
-  ...toplevelTaskNames,
-  ...traceEventsToKeepInToplevelTask,
-
-  // See the DevTools marker events
-  // https://source.chromium.org/chromium/chromium/src/+/main:third_party/devtools-frontend/src/front_end/timeline_model/TimelineModel.js?q=-f:out%20f:TimelineModel%20%22MarkLoad:%20%27%22&ss=chromium
-  'firstPaint',
-  'firstContentfulPaint',
-  'firstMeaningfulPaint',
-  'firstMeaningfulPaintCandidate',
-  'loadEventEnd',
-  'MarkLoad',
-  'domContentLoadedEventEnd',
-  'MarkDOMContent',
-  'largestContentfulPaint::Invalidate',
-  'largestContentfulPaint::Candidate',
-  'Animation',
-]);
-
-/**
- * @param {LH.TraceEvent[]} events
- */
-function filterOutUnnecessaryTasksByNameAndDuration(events) {
-  const {pid} = TraceProcessor.findMainFrameIds(events);
-
-  return events.filter(evt => {
-    if (toplevelTaskNames.has(evt.name) && evt.dur < 1000) return false;
-    if (evt.pid === pid && traceEventsToKeepInProcess.has(evt.name)) return true;
-    if (traceCategoriesToAlwaysKeep.has(evt.cat)) return true;
-    return traceEventsToAlwaysKeep.has(evt.name);
-  });
-}
-
-/**
- * Filters out tasks that are not within a toplevel task.
- * @param {LH.TraceEvent[]} events
- */
-function filterOutOrphanedTasks(events) {
-  const toplevelRanges = events
-    .filter(evt => toplevelTaskNames.has(evt.name))
-    .map(evt => [evt.ts, evt.ts + evt.dur]);
-
-  /** @param {LH.TraceEvent} e */
-  const isInToplevelTask = e => toplevelRanges.some(([start, end]) => e.ts >= start && e.ts <= end);
-
-  return events.filter((evt, index) => {
-    if (!traceEventsToKeepInToplevelTask.has(evt.name)) return true;
-    if (!isInToplevelTask(evt)) return false;
-
-    if (evt.ph === 'B') {
-      const endEvent = events.slice(index).find(e => e.name === evt.name && e.ph === 'E');
-      return endEvent && isInToplevelTask(endEvent);
-    } else {
-      return true;
-    }
-  });
-}
-
-/**
- * Throttles screenshot events in the trace to 2fps.
- * @param {LH.TraceEvent[]} events
- */
-function filterOutExcessiveScreenshots(events) {
-  const screenshotTimestamps = events.filter(evt => evt.name === 'Screenshot').map(evt => evt.ts);
-
-  let lastScreenshotTs = -Infinity;
-  return events.filter(evt => {
-    if (evt.name !== 'Screenshot') return true;
-    const timeSinceLastScreenshot = evt.ts - lastScreenshotTs;
-    const nextScreenshotTs = screenshotTimestamps.find(ts => ts > evt.ts);
-    const timeUntilNextScreenshot = nextScreenshotTs ? nextScreenshotTs - evt.ts : Infinity;
-    const threshold = 500 * 1000; // Throttle to ~2fps
-    // Keep the frame if it's been more than 500ms since the last frame we kept or the next frame won't happen for at least 500ms
-    const shouldKeep = timeUntilNextScreenshot > threshold || timeSinceLastScreenshot > threshold;
-    if (shouldKeep) lastScreenshotTs = evt.ts;
-    return shouldKeep;
-  });
-}
-
-/**
- * @param {LH.TraceEvent[]} events
- */
-function filterTraceEvents(events) {
-  // Filter out event names we don't care about and tasks <1ms
-  let filtered = filterOutUnnecessaryTasksByNameAndDuration(events);
-  // Filter out events not inside a toplevel task
-  filtered = filterOutOrphanedTasks(filtered);
-  // Filter down the screenshots to key moments + 2fps animations
-  return filterOutExcessiveScreenshots(filtered);
-}
-
-/**
- * @param {LH.Trace} inputTrace
- * @return {LH.Trace}
- */
-function minifyTrace(inputTrace) {
-  return {traceEvents: filterTraceEvents(inputTrace.traceEvents)};
-}
-
-export {minifyTrace};