Performance monitoring (#396)

* Performance monitoring

* Refactor class use and add basic sanity check

* Rename measure on PerformanceMonitor to measureAll

Author: jonathanKingston

integration-test/test-performance.js

@@ -0,0 +1,55 @@
+/**
+ *  Tests for basic performance
+ */
+import { setup } from './helpers/harness.js'
+
+describe('Runtime checks: should check basic performance', () => {
+    let browser
+    let server
+    let teardown
+    let setupServer
+    let gotoAndWait
+    beforeAll(async () => {
+        ({ browser, setupServer, teardown, gotoAndWait } = await setup({ withExtension: true }))
+        server = setupServer()
+    })
+    afterAll(async () => {
+        await server?.close()
+        await teardown()
+    })
+
+    it('Should perform within a resonable timeframe', async () => {
+        const port = server.address().port
+        const page = await browser.newPage()
+        await gotoAndWait(page, `http://localhost:${port}/blank.html`, {
+            debug: true,
+            site: {
+                enabledFeatures: ['runtimeChecks', 'fingerprintingCanvas']
+            },
+            featureSettings: {
+                runtimeChecks: {
+                    taintCheck: 'enabled',
+                    matchAllDomains: 'enabled',
+                    matchAllStackDomains: 'disabled',
+                    overloadInstanceOf: 'enabled',
+                    stackDomains: [
+                        {
+                            domain: 'localhost'
+                        }
+                    ]
+                }
+            }
+        })
+        const perfResult = await page.evaluate(
+            () => {
+                return {
+                    load: performance.getEntriesByName('load')[0].duration,
+                    init: performance.getEntriesByName('init')[0].duration,
+                    runtimeChecks: performance.getEntriesByName('runtimeChecksCallInit')[0].duration
+                }
+            })
+        expect(perfResult.runtimeChecks).toBeLessThan(2)
+        expect(perfResult.load).toBeLessThan(3)
+        expect(perfResult.init).toBeLessThan(15)
+    })
+})

src/content-feature.js

@@ -1,10 +1,12 @@
 import { camelcase, matchHostname, processAttr } from './utils.js'
 import { immutableJSONPatch } from 'immutable-json-patch'
+import { PerformanceMonitor } from './performance.js'
 
 export default class ContentFeature {
     constructor (featureName) {
         this.name = featureName
         this._args = null
+        this.monitor = new PerformanceMonitor()
     }
 
     /**
@@ -86,18 +88,29 @@ export default class ContentFeature {
     }
 
     callInit (args) {
+        const mark = this.monitor.mark(this.name + 'CallInit')
         this._args = args
         this.platform = args.platform
         this.init(args)
+        mark.end()
+        this.measure()
     }
 
     load (args) {
     }
 
     callLoad (args) {
+        const mark = this.monitor.mark(this.name + 'CallLoad')
         this._args = args
         this.platform = args.platform
         this.load(args)
+        mark.end()
+    }
+
+    measure () {
+        if (this._args.debug) {
+            this.monitor.measureAll()
+        }
     }
 
     update () {

src/content-scope-features.js

@@ -1,6 +1,7 @@
 /* global mozProxies */
 import { initStringExemptionLists, isFeatureBroken, registerMessageSecret, getInjectionElement } from './utils'
 import { featureNames } from './features'
+import { PerformanceMonitor } from './performance'
 // @ts-expect-error Special glob import for injected features see scripts/utils/build.js
 import injectedFeaturesCode from 'ddg:runtimeInjects'
 
@@ -20,6 +21,7 @@ let initArgs = null
 const updates = []
 const features = []
 const alwaysInitFeatures = new Set(['cookie'])
+const performanceMonitor = new PerformanceMonitor()
 
 /**
  * @typedef {object} LoadArgs
@@ -34,6 +36,7 @@ const alwaysInitFeatures = new Set(['cookie'])
  * @param {LoadArgs} args
  */
 export async function load (args) {
+    const mark = performanceMonitor.mark('load')
     if (!shouldRun()) {
         return
     }
@@ -52,6 +55,7 @@ export async function load (args) {
         })
         features.push(feature)
     }
+    mark.end()
 }
 
 /**
@@ -105,6 +109,7 @@ function supportsInjectedFeatures () {
 }
 
 export async function init (args) {
+    const mark = performanceMonitor.mark('init')
     initArgs = args
     if (!shouldRun()) {
         return
@@ -125,6 +130,10 @@ export async function init (args) {
         const update = updates.pop()
         await updateFeaturesInner(update)
     }
+    mark.end()
+    if (args.debug) {
+        performanceMonitor.measureAll()
+    }
 }
 
 export async function update (args) {

src/performance.js

@@ -0,0 +1,49 @@
+/**
+ * Performance monitor, holds reference to PerformanceMark instances.
+ */
+export class PerformanceMonitor {
+    constructor () {
+        this.marks = []
+    }
+
+    /**
+     * Create performance marker
+     * @param {string} name
+     * @returns {PerformanceMark}
+     */
+    mark (name) {
+        const mark = new PerformanceMark(name)
+        this.marks.push(mark)
+        return mark
+    }
+
+    /**
+     * Measure all performance markers
+     */
+    measureAll () {
+        this.marks.forEach((mark) => {
+            mark.measure()
+        })
+    }
+}
+
+/**
+ * Tiny wrapper around performance.mark and performance.measure
+ */
+export class PerformanceMark {
+    /**
+     * @param {string} name
+     */
+    constructor (name) {
+        this.name = name
+        performance.mark(this.name + 'Start')
+    }
+
+    end () {
+        performance.mark(this.name + 'End')
+    }
+
+    measure () {
+        performance.measure(this.name, this.name + 'Start', this.name + 'End')
+    }
+}

unit-test/verify-artifacts.js

@@ -6,7 +6,7 @@ import { cwd } from '../scripts/script-utils.js'
 const ROOT = join(cwd(import.meta.url), '..')
 const BUILD = join(ROOT, 'build')
 const APPLE_BUILD = join(ROOT, 'Sources/ContentScopeScripts/dist')
-const CSS_OUTPUT_SIZE = 530000
+const CSS_OUTPUT_SIZE = 550000
 const CSS_OUTPUT_SIZE_CHROME = CSS_OUTPUT_SIZE * 1.45 // 45% larger for Chrome MV2 due to base64 encoding
 
 const checks = {