feat(core): optimize string reuse in high traffic

Author: blakebyrnes

client/lib/Handler.ts

@@ -150,7 +150,7 @@ export default class Handler {
     const dispatches = [...this.dispatches];
     // clear out dispatches everytime you check it
     this.dispatches.length = 0;
-    const startStack = new Error('').stack.split(/\r?\n/).slice(1).join('\n');
+    const startStack = new Error('').stack.slice(8); // "Error: \n" is 8 chars
     await Promise.all(
       dispatches.map(async dispatch => {
         const err = await dispatch.resolution;
@@ -200,7 +200,9 @@ export default class Handler {
   }
 
   private getConnection(): ConnectionToCore {
-    return pickRandom(this.getAvailableConnections());
+    const connections = this.getAvailableConnections();
+    if (!connections.length) throw new Error('There are no active Core connections available.');
+    return pickRandom(connections);
   }
 
   private registerUnhandledExceptionHandlers(): void {

commons/Queue.ts

@@ -25,7 +25,7 @@ export default class Queue {
     this.queue.push({
       promise,
       cb,
-      startStack: new Error('').stack.split(/\r?\n/).slice(1).join('\n'),
+      startStack: new Error('').stack.slice(8), // "Error: \n" is 8 chars
     });
 
     this.next().catch(() => null);

commons/Resolvable.ts

@@ -14,11 +14,13 @@ export default class Resolvable<T = any> implements IResolvablePromise<T>, Promi
 
   constructor(timeoutMillis?: number, timeoutMessage?: string) {
     // get parent stack
-    const error = new TimeoutError(timeoutMessage);
-    this.stack = error.stack.split(/\r?\n/).slice(2).join('\n');
+    this.stack = new Error('').stack.slice(8);
 
     if (timeoutMillis !== undefined && timeoutMillis !== null) {
-      this.timeout = setTimeout(this.reject.bind(this, error), timeoutMillis).unref();
+      this.timeout = setTimeout(
+        this.rejectWithTimeout.bind(this, timeoutMessage),
+        timeoutMillis,
+      ).unref();
     }
     this.promise = new Promise<T>((resolve, reject) => {
       this.resolveFn = resolve;
@@ -70,4 +72,10 @@ export default class Resolvable<T = any> implements IResolvablePromise<T>, Promi
   public finally(onfinally?: () => void): Promise<T> {
     return this.promise.finally(onfinally);
   }
+
+  private rejectWithTimeout(message: string): void {
+    const error = new TimeoutError(message);
+    error.stack = `TimeoutError: ${message}\n${this.stack}`;
+    this.reject(error);
+  }
 }

commons/TypeSerializer.ts

@@ -1,3 +1,21 @@
+const Types = {
+  Number: 'number',
+  String: 'string',
+  Boolean: 'boolean',
+  Object: 'object',
+  BigInt: 'bigint',
+  NaN: 'NaN',
+  Infinity: 'Infinity',
+  NegativeInfinity: '-Infinity',
+  DateIso: 'DateIso',
+  Buffer64: 'Buffer64',
+  ArrayBuffer64: 'ArrayBuffer64',
+  RegExp: 'RegExp',
+  Map: 'Map',
+  Set: 'Set',
+  Error: 'Error',
+};
+
 export default class TypeSerializer {
   public static errorTypes = new Map<string, { new (message?: string): Error }>();
   private static isNodejs = typeof process !== 'undefined' && process.release.name === 'node';
@@ -8,12 +26,13 @@ export default class TypeSerializer {
 
       const { value, type } = entry;
 
-      if (type === 'BigInt') return BigInt(value);
-      if (type === 'NaN') return Number.NaN;
-      if (type === 'Infinity') return Number.POSITIVE_INFINITY;
-      if (type === '-Infinity') return Number.NEGATIVE_INFINITY;
-      if (type === 'DateIso') return new Date(value);
-      if (type === 'Buffer64' || type === 'ArrayBuffer64') {
+      if (type === Types.Number || type === Types.String || type === Types.Boolean) return value;
+      if (type === Types.BigInt) return BigInt(value);
+      if (type === Types.NaN) return Number.NaN;
+      if (type === Types.Infinity) return Number.POSITIVE_INFINITY;
+      if (type === Types.NegativeInfinity) return Number.NEGATIVE_INFINITY;
+      if (type === Types.DateIso) return new Date(value);
+      if (type === Types.Buffer64 || type === Types.ArrayBuffer64) {
         if (this.isNodejs) {
           return Buffer.from(value, 'base64');
         }
@@ -27,10 +46,10 @@ export default class TypeSerializer {
 
         return new globalThis[arrayType](uint8Array.buffer, byteOffset, byteLength);
       }
-      if (type === 'RegExp') return new RegExp(value[0], value[1]);
-      if (type === 'Map') return new Map(value);
-      if (type === 'Set') return new Set(value);
-      if (type === 'Error') {
+      if (type === Types.RegExp) return new RegExp(value[0], value[1]);
+      if (type === Types.Map) return new Map(value);
+      if (type === Types.Set) return new Set(value);
+      if (type === Types.Error) {
         const { name, message, stack, ...data } = value;
         let Constructor = this.errorTypes && this.errorTypes.get(name);
         if (!Constructor) {
@@ -41,7 +60,8 @@ export default class TypeSerializer {
           }
         }
 
-        const startStack = new Error('').stack.split(/\r?\n/).slice(1).join('\n');
+        const startStack = new Error('').stack.slice(8); // "Error: \n" is 8 chars
+
         const e = new Constructor(message);
         e.name = name;
         Object.assign(e, data);
@@ -57,7 +77,7 @@ export default class TypeSerializer {
 
   public static stringify(object: any): string {
     return JSON.stringify(object, (key, value) => {
-      if (value && typeof value === 'object' && !Array.isArray(value)) {
+      if (value && typeof value === Types.Object && !Array.isArray(value)) {
         const resultObject = {};
         for (const [k, v] of Object.entries(value)) {
           resultObject[k] = this.convertKeyValue(k, v);
@@ -69,57 +89,57 @@ export default class TypeSerializer {
   }
 
   private static convertKeyValue(_: string, value: any): any {
+    if (value === null || value === undefined) return value;
+
     if (Number.isNaN(value)) {
-      return { type: 'NaN' };
+      return { type: Types.NaN };
     }
 
     if (value === Number.POSITIVE_INFINITY) {
-      return { type: 'Infinity' };
+      return { type: Types.Infinity };
     }
 
     if (value === Number.NEGATIVE_INFINITY) {
-      return { type: '-Infinity' };
+      return { type: Types.NegativeInfinity };
     }
 
-    if (value === null || value === undefined) return value;
-
     const type = typeof value;
-    if (type === 'boolean' || type === 'string' || type === 'number') return value;
-    if (type === 'bigint') {
-      return { type: 'BigInt', value: value.toString() };
+    if (type === Types.Boolean || type === Types.String || type === Types.Number) return value;
+    if (type === Types.BigInt) {
+      return { type: Types.BigInt, value: value.toString() };
     }
 
     if (value instanceof Date) {
-      return { type: 'DateIso', value: value.toISOString() };
+      return { type: Types.DateIso, value: value.toISOString() };
     }
 
     if (value instanceof RegExp) {
-      return { type: 'RegExp', value: [value.source, value.flags] };
+      return { type: Types.RegExp, value: [value.source, value.flags] };
     }
 
     if (value instanceof Error) {
       const { name, message, stack, ...data } = value;
-      return { type: 'Error', value: { name, message, stack, ...data } };
+      return { type: Types.Error, value: { name, message, stack, ...data } };
     }
 
     if (value instanceof Map) {
-      return { type: 'Map', value: [...value.entries()] };
+      return { type: Types.Map, value: [...value.entries()] };
     }
 
     if (value instanceof Set) {
-      return { type: 'Set', value: [...value] };
+      return { type: Types.Set, value: [...value] };
     }
 
     if (this.isNodejs) {
       if (value instanceof Buffer || Buffer.isBuffer(value)) {
-        return { type: 'Buffer64', value: value.toString('base64') };
+        return { type: Types.Buffer64, value: value.toString('base64') };
       }
     } else {
       if (ArrayBuffer.isView(value)) {
         // @ts-ignore
         const binary = new TextDecoder('utf8').decode(value.buffer);
         return {
-          type: 'ArrayBuffer64',
+          type: Types.ArrayBuffer64,
           value: globalThis.btoa(binary),
           args: {
             arrayType: value[Symbol.toStringTag],
@@ -132,7 +152,7 @@ export default class TypeSerializer {
         // @ts-ignore
         const binary = new TextDecoder('utf8').decode(value);
         return {
-          type: 'ArrayBuffer64',
+          type: Types.ArrayBuffer64,
           value: globalThis.btoa(binary),
         };
       }
@@ -148,4 +168,6 @@ export function registerSerializableErrorType(errorConstructor: {
   TypeSerializer.errorTypes.set(errorConstructor.name, errorConstructor);
 }
 
-export const stringifiedTypeSerializerClass = TypeSerializer.toString();
+export const stringifiedTypeSerializerClass = `const Types = ${JSON.stringify(
+  Types,
+)};\n${TypeSerializer.toString()}`;

core-interfaces/IDomChangeEvent.ts

@@ -3,12 +3,17 @@ import type { UnixTimestamp } from './GenericTypes';
 
 type Idx = number;
 
-export type IDomChangeEvent = [
-  'newDocument' | 'location' | 'added' | 'removed' | 'text' | 'attribute' | 'property',
-  INodeData,
-  UnixTimestamp,
-  Idx,
-];
+export type IDomChangeEvent = [DomActionType, INodeData, UnixTimestamp, Idx];
+
+export enum DomActionType {
+  newDocument = 0,
+  location = 1,
+  added = 2,
+  removed = 3,
+  text = 4,
+  attribute = 5,
+  property = 6,
+}
 
 export interface INodeData {
   id: number;

core-interfaces/IFocusEvent.ts

@@ -3,6 +3,10 @@ import { UnixTimestamp } from './GenericTypes';
 
 type NodeId = number;
 type RelatedNodeId = NodeId;
-type FocusEventType = 'in' | 'out';
+
+export enum FocusEventType {
+  IN = 0,
+  OUT = 1,
+}
 
 export type IFocusEvent = [FocusEventType, NodeId, RelatedNodeId, UnixTimestamp];

core-interfaces/INavigation.ts

@@ -15,7 +15,18 @@ export default interface INavigation {
   stateChanges: Map<NavigationState, Date>;
 }
 
-export type NavigationState = Exclude<IPipelineStatus, 'PaintingStable'> | 'Load' | 'ContentPaint';
+export enum LoadStatus {
+  NavigationRequested = 'NavigationRequested',
+  HttpRequested = 'HttpRequested',
+  HttpRedirected = 'HttpRedirected',
+  HttpResponded = 'HttpResponded',
+
+  DomContentLoaded = 'DomContentLoaded',
+  Load = 'Load',
+  ContentPaint = 'ContentPaint',
+}
+
+export type NavigationState = keyof typeof LoadStatus;
 
 export type NavigationReason =
   | DevToolsNavigationReason