ump-plugin-performance

Web-spec performance (User-Timing API) and PerformanceObserver / PerformanceObserverEntryList for UMP apps. Backed by the C++ __ump_perf_now host bridge for sub-ms steady-clock timestamps; falls back to host performance.now then Date.now().

Install

npm install ump-plugin-performance

Peer dependencies (must already be installed in your app):

• ump-core
• ump-native

Usage

Importing the plugin (or its barrel) installs globalThis.performance (only filling in what the host is missing — never overrides) and the PerformanceObserver / PerformanceObserverEntryList constructors. The same surface is also exported as named ES modules.

import { performance, PerformanceObserver } from 'ump-plugin-performance';

performance.mark('boot-start');
// … do work …
performance.mark('boot-end');
const m = performance.measure('boot', 'boot-start', 'boot-end');
console.log('boot took', m.duration, 'ms');

const po = new PerformanceObserver((list) => {
    for (const entry of list.getEntries()) {
        console.log(entry.entryType, entry.name, entry.duration);
    }
});
po.observe({ entryTypes: ['mark', 'measure'] });
// po.disconnect();

buffered: true (single-type form) seeds the first callback with the existing entries of that type:

new PerformanceObserver((list) => { /* … */ })
    .observe({ type: 'mark', buffered: true });

Spec deviations (v1)

• Entry types: only mark and measure are supported. No navigation / resource / longtask / paint entries are synthesised; passing them to observe() is silently dropped.
• Storage cap: the entry buffer holds at most 150 entries; oldest dropped on overflow (browsers cap at 150 marks by default).
• performance.timeOrigin is captured once at module load via Date.now() and is stable for the process lifetime.
• Host preservation: if the host already exposes both performance.now and performance.mark, the plugin skips installation entirely. If only now is present, the User-Timing methods are grafted onto the existing object without replacing now / timeOrigin.
• Observer callbacks are dispatched via queueMicrotask, batching all entries seen since the last fire into a single call. Listener exceptions are caught and logged via console.error; they never block other observers.

Migration from ump-native

In ump-native 0.1.x, performance, PerformanceObserver, and PerformanceObserverEntryList were bundled with the main package. Starting 0.2.x, they ship as this separate plugin.

- import { performance, PerformanceObserver } from 'ump-native';
+ import { performance, PerformanceObserver } from 'ump-plugin-performance';

No API changes.