Files
umami/src/lib/replay.ts
T

212 lines
4.9 KiB
TypeScript

export const RRWEB_EVENT_TYPE = {
Meta: 4,
FullSnapshot: 2,
} as const;
export const REPLAY_EVENT_FRAGMENT_TYPE = 'umami:rrweb-event-fragment';
interface ReplayEventFragment {
type: typeof REPLAY_EVENT_FRAGMENT_TYPE;
timestamp?: number;
data: {
id: string;
index: number;
total: number;
value: string;
};
}
export function isReplayEventFragment(event: any): event is ReplayEventFragment {
const { data } = event || {};
return (
event?.type === REPLAY_EVENT_FRAGMENT_TYPE &&
typeof data?.id === 'string' &&
Number.isInteger(data?.index) &&
Number.isInteger(data?.total) &&
data.index >= 0 &&
data.index < data.total &&
typeof data?.value === 'string'
);
}
export function getReplayEventCount(events: any[] | null | undefined) {
if (!Array.isArray(events)) {
return 0;
}
return events.reduce((count, event) => {
if (isReplayEventFragment(event)) {
return count + (event.data.index === 0 ? 1 : 0);
}
return count + 1;
}, 0);
}
export function restoreReplayEventFragments(events: any[] | null | undefined) {
if (!Array.isArray(events)) {
return [];
}
const restored: any[] = [];
const pending = new Map<
string,
{
total: number;
values: Map<number, string>;
received: number;
}
>();
for (const event of events) {
if (!isReplayEventFragment(event)) {
restored.push(event);
continue;
}
const { id, index, total, value } = event.data;
let fragment = pending.get(id);
if (!fragment || fragment.total !== total) {
fragment = {
total,
values: new Map(),
received: 0,
};
pending.set(id, fragment);
}
if (!fragment.values.has(index)) {
fragment.values.set(index, value);
fragment.received += 1;
}
if (fragment.received === fragment.total) {
pending.delete(id);
try {
let serialized = '';
for (let i = 0; i < fragment.total; i++) {
serialized += fragment.values.get(i) || '';
}
restored.push(JSON.parse(serialized));
} catch {
// Ignore malformed fragment groups. A partial replay is better than failing the whole response.
}
}
}
return restored;
}
export function hasReplayFullSnapshot(events: any[] | null | undefined) {
return (
Array.isArray(events) && events.some(event => event?.type === RRWEB_EVENT_TYPE.FullSnapshot)
);
}
export function hasReplayableFullSnapshot(events: any[] | null | undefined) {
return (
Array.isArray(events) &&
events.some(event => {
const { data } = event || {};
const { node } = data || {};
return (
event?.type === RRWEB_EVENT_TYPE.FullSnapshot &&
Number.isInteger(node?.type) &&
Array.isArray(node?.childNodes)
);
})
);
}
export function hasReplayMeta(events: any[] | null | undefined) {
return Array.isArray(events) && events.some(event => event?.type === RRWEB_EVENT_TYPE.Meta);
}
function getReplayDimension(value: any) {
const dimension = Number(value);
return Number.isFinite(dimension) && dimension > 0 ? dimension : null;
}
export function getReplayViewport(events: any[] | null | undefined) {
if (!Array.isArray(events)) {
return null;
}
const meta = events.find(event => {
const width = getReplayDimension(event?.data?.width);
const height = getReplayDimension(event?.data?.height);
return event?.type === RRWEB_EVENT_TYPE.Meta && width && height;
});
if (!meta) {
return null;
}
return {
width: getReplayDimension(meta.data.width) as number,
height: getReplayDimension(meta.data.height) as number,
};
}
function getReplayTimestamp(event: any) {
const timestamp = Number(event?.timestamp);
return Number.isFinite(timestamp) ? timestamp : null;
}
export function getReplayPlayerEvents(events: any[] | null | undefined) {
if (!Array.isArray(events)) {
return [];
}
const replayEvents = events.filter(
event => event && typeof event === 'object' && event.type !== undefined && event.type !== null,
);
if (!hasReplayableFullSnapshot(replayEvents)) {
return [];
}
const firstTimestamp =
replayEvents.map(getReplayTimestamp).find(timestamp => timestamp !== null) ?? Date.now();
let lastTimestamp = firstTimestamp - 1;
const normalizedEvents = replayEvents.map(event => {
const timestamp = getReplayTimestamp(event);
if (timestamp !== null) {
lastTimestamp = timestamp;
return typeof event.timestamp === 'number' ? event : { ...event, timestamp };
}
lastTimestamp += 1;
return { ...event, timestamp: lastTimestamp };
});
if (normalizedEvents.length === 1) {
return [
normalizedEvents[0],
{
...normalizedEvents[0],
timestamp: normalizedEvents[0].timestamp + 1,
},
];
}
return normalizedEvents;
}
export function canReplayEvents(events: any[] | null | undefined) {
return getReplayPlayerEvents(events).length >= 2;
}