overleaf/services/web/frontend/js/infrastructure/cm6-performance.ts

297 lines
8 KiB
TypeScript
Raw Normal View History

import { Transaction } from '@codemirror/state'
import { EditorView } from '@codemirror/view'
import { round } from 'lodash'
import grammarlyExtensionPresent from '../shared/utils/grammarly'
import getMeta from '../utils/meta'
const TIMER_START_NAME = 'CM6-BeforeUpdate'
const TIMER_END_NAME = 'CM6-AfterUpdate'
const TIMER_DOM_UPDATE_NAME = 'CM6-DomUpdate'
const TIMER_MEASURE_NAME = 'CM6-Update'
const TIMER_KEYPRESS_MEASURE_NAME = 'CM6-Keypress-Measure'
let latestDocLength = 0
const sessionStart = Date.now()
let performanceOptionsSupport = false
// Check that performance.mark and performance.measure accept an options object
try {
const testMarkName = 'featureTestMark'
performance.mark(testMarkName, {
startTime: performance.now(),
detail: { test: 1 },
})
performance.clearMarks(testMarkName)
const testMeasureName = 'featureTestMeasure'
performance.measure(testMeasureName, {
start: performance.now(),
detail: { test: 1 },
})
performance.clearMeasures(testMeasureName)
performanceOptionsSupport = true
} catch (e) {}
let performanceMemorySupport = false
function measureMemoryUsage() {
// @ts-ignore
return performance.memory.usedJSHeapSize
}
try {
if ('memory' in window.performance) {
measureMemoryUsage()
performanceMemorySupport = true
}
} catch (e) {}
let performanceLongtaskSupported = false
let longTaskSinceLastReportCount = 0
// Detect support for long task monitoring
try {
if (PerformanceObserver.supportedEntryTypes.includes('longtask')) {
performanceLongtaskSupported = true
// Register observer for long task notifications
const observer = new PerformanceObserver(list => {
longTaskSinceLastReportCount += list.getEntries().length
})
observer.observe({ entryTypes: ['longtask'] })
}
} catch (e) {}
function isInputOrDelete(userEventType: string | undefined) {
return (
!!userEventType && ['input', 'delete'].includes(userEventType.split('.')[0])
)
}
// "keypress" is not strictly accurate; what we really mean is a user-initiated
// event that either inserts or deletes exactly one character. This corresponds
// to CM6 user event types input.type, delete.forward or delete.backward
function isKeypress(userEventType: string | undefined) {
return (
!!userEventType &&
['input.type', 'delete.forward', 'delete.backward'].includes(userEventType)
)
}
export function dispatchTimer(): {
start: (tr: Transaction) => void
end: (tr: Transaction, view: EditorView) => void
} {
if (!performanceOptionsSupport) {
return { start: () => {}, end: () => {} }
}
let userEventsSinceDomUpdateCount = 0
let keypressesSinceDomUpdateCount = 0
const unpaintedKeypressStartTimes: number[] = []
const start = (tr: Transaction) => {
const userEventType = tr.annotation(Transaction.userEvent)
if (isKeypress(userEventType)) {
unpaintedKeypressStartTimes.push(performance.now())
}
performance.mark(TIMER_START_NAME)
}
const end = (tr: Transaction, view: EditorView) => {
performance.mark(TIMER_END_NAME)
const userEventType = tr.annotation(Transaction.userEvent)
if (isInputOrDelete(userEventType)) {
++userEventsSinceDomUpdateCount
if (isKeypress(userEventType)) {
++keypressesSinceDomUpdateCount
}
performance.measure(TIMER_MEASURE_NAME, {
start: TIMER_START_NAME,
end: TIMER_END_NAME,
detail: { userEventType, userEventsSinceDomUpdateCount },
})
// The `key` property ensures that the measurement task is only run once
// per measure phase
view.requestMeasure({
key: 'inputEventCounter',
read() {
performance.mark(TIMER_DOM_UPDATE_NAME, {
detail: { keypressesSinceDomUpdateCount },
})
userEventsSinceDomUpdateCount = 0
keypressesSinceDomUpdateCount = 0
const keypressEnd = performance.now()
for (const keypressStart of unpaintedKeypressStartTimes) {
performance.measure(TIMER_KEYPRESS_MEASURE_NAME, {
start: keypressStart,
end: keypressEnd,
})
}
unpaintedKeypressStartTimes.length = 0
},
})
}
latestDocLength = tr.state.doc.length
}
return { start, end }
}
function calculateMean(durations: number[]) {
if (durations.length === 0) return 0
const sum = durations.reduce((acc, entry) => acc + entry, 0)
return sum / durations.length
}
function calculateMedian(sortedDurations: number[]) {
if (sortedDurations.length === 0) return 0
const middle = Math.floor(sortedDurations.length / 2)
if (sortedDurations.length % 2 === 0) {
return (sortedDurations[middle - 1] + sortedDurations[middle]) / 2
}
return sortedDurations[middle]
}
function calculate95thPercentile(sortedDurations: number[]) {
if (sortedDurations.length === 0) return 0
const index = Math.round((sortedDurations.length - 1) * 0.95)
return sortedDurations[index]
}
function calculateMax(numbers: number[]) {
return numbers.reduce((a, b) => Math.max(a, b), 0)
}
export function reportCM6Perf() {
// Get entries triggered by keystrokes
const cm6Entries = performance.getEntriesByName(
TIMER_MEASURE_NAME,
'measure'
) as PerformanceMeasure[]
performance.clearMeasures(TIMER_MEASURE_NAME)
performance.clearMarks(TIMER_START_NAME)
performance.clearMarks(TIMER_END_NAME)
const inputEvents = cm6Entries.filter(({ detail }) =>
isInputOrDelete(detail.userEventType)
)
const inputDurations = inputEvents
.map(({ duration }) => duration)
.sort((a, b) => a - b)
const max = round(calculateMax(inputDurations), 2)
const mean = round(calculateMean(inputDurations), 2)
const median = round(calculateMedian(inputDurations), 2)
const ninetyFifthPercentile = round(
calculate95thPercentile(inputDurations),
2
)
const maxUserEventsBetweenDomUpdates = calculateMax(
inputEvents.map(e => e.detail.userEventsSinceDomUpdateCount)
)
const grammarly = grammarlyExtensionPresent()
const sessionLength = Math.floor((Date.now() - sessionStart) / 1000) // In seconds
const memory = performanceMemorySupport ? measureMemoryUsage() : null
// Get entries for keypress counts between DOM updates
const domUpdateEntries = performance.getEntriesByName(
TIMER_DOM_UPDATE_NAME,
'mark'
) as PerformanceMark[]
performance.clearMarks(TIMER_DOM_UPDATE_NAME)
let lags = 0
let nonLags = 0
let longestLag = 0
let totalKeypressCount = 0
for (const entry of domUpdateEntries) {
const keypressCount = entry.detail.keypressesSinceDomUpdateCount
if (keypressCount === 1) {
++nonLags
} else if (keypressCount > 1) {
++lags
}
if (keypressCount > longestLag) {
longestLag = keypressCount
}
totalKeypressCount += keypressCount
}
const meanLagsPerMeasure = round(lags / (lags + nonLags), 4)
const meanKeypressesPerMeasure = round(
totalKeypressCount / (lags + nonLags),
4
)
// Get entries triggered by keystrokes
const keypressPaintEntries = performance.getEntriesByName(
TIMER_KEYPRESS_MEASURE_NAME,
'measure'
) as PerformanceMeasure[]
const keypressPaintDurations = keypressPaintEntries.map(
({ duration }) => duration
)
const meanKeypressPaint = round(calculateMean(keypressPaintDurations), 2)
performance.clearMeasures(TIMER_KEYPRESS_MEASURE_NAME)
let longTasks = null
// Get long task entries (Chromium-based browsers only at time of writing)
if (performanceLongtaskSupported) {
longTasks = longTaskSinceLastReportCount
longTaskSinceLastReportCount = 0
}
const release = getMeta('ol-ExposedSettings')?.sentryRelease || null
return {
max,
mean,
median,
ninetyFifthPercentile,
maxUserEventsBetweenDomUpdates,
docLength: latestDocLength,
numberOfEntries: inputDurations.length,
grammarly,
sessionLength,
memory,
lags,
nonLags,
longestLag,
meanLagsPerMeasure,
meanKeypressesPerMeasure,
meanKeypressPaint,
longTasks,
release,
}
}
window._reportCM6Perf = () => {
console.log(reportCM6Perf())
}