682 lines
24 KiB
JavaScript
682 lines
24 KiB
JavaScript
// ============================
|
|
// DB Monitor — Dashboard App
|
|
// ============================
|
|
|
|
(function () {
|
|
'use strict';
|
|
|
|
// State
|
|
let currentDB = '';
|
|
let charts = {};
|
|
let refreshInterval = null;
|
|
let allDBStatuses = [];
|
|
const REFRESH_MS = 5000;
|
|
|
|
// ---- DOM refs ----
|
|
const $ = (sel) => document.querySelector(sel);
|
|
const dbSelector = $('#db-selector');
|
|
const lastUpdateEl = $('#last-update');
|
|
|
|
// ---- Init ----
|
|
document.addEventListener('DOMContentLoaded', () => {
|
|
initCharts();
|
|
fetchDatabases();
|
|
startAutoRefresh();
|
|
|
|
dbSelector.addEventListener('change', () => {
|
|
currentDB = dbSelector.value;
|
|
fetchMetrics();
|
|
refreshCharts();
|
|
updateOverviewHighlight();
|
|
});
|
|
|
|
// Chart range buttons
|
|
document.querySelectorAll('.chart-controls').forEach(controls => {
|
|
controls.querySelectorAll('.chart-range').forEach(btn => {
|
|
btn.addEventListener('click', () => {
|
|
controls.querySelectorAll('.chart-range').forEach(b => b.classList.remove('active'));
|
|
btn.classList.add('active');
|
|
refreshCharts();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
// ---- Auto refresh ----
|
|
function startAutoRefresh() {
|
|
if (refreshInterval) clearInterval(refreshInterval);
|
|
refreshInterval = setInterval(() => {
|
|
fetchDatabaseOverview();
|
|
fetchMetrics();
|
|
refreshCharts();
|
|
}, REFRESH_MS);
|
|
}
|
|
|
|
// ---- Fetch databases list ----
|
|
async function fetchDatabases() {
|
|
try {
|
|
const res = await fetch('/api/status');
|
|
const data = await res.json();
|
|
|
|
if (data.databases && data.databases.length > 0) {
|
|
allDBStatuses = data.databases;
|
|
dbSelector.innerHTML = '';
|
|
data.databases.forEach(db => {
|
|
const opt = document.createElement('option');
|
|
opt.value = db.name;
|
|
opt.textContent = db.name;
|
|
dbSelector.appendChild(opt);
|
|
});
|
|
currentDB = data.databases[0].name;
|
|
dbSelector.value = currentDB;
|
|
renderDBOverview(data.databases);
|
|
fetchMetrics();
|
|
refreshCharts();
|
|
} else {
|
|
dbSelector.innerHTML = '<option>Waiting for data...</option>';
|
|
setTimeout(fetchDatabases, 3000);
|
|
}
|
|
} catch (e) {
|
|
dbSelector.innerHTML = '<option>Connection error</option>';
|
|
setTimeout(fetchDatabases, 5000);
|
|
}
|
|
}
|
|
|
|
// ---- Fetch DB overview ----
|
|
async function fetchDatabaseOverview() {
|
|
try {
|
|
const res = await fetch('/api/status');
|
|
const data = await res.json();
|
|
if (data.databases && data.databases.length > 0) {
|
|
allDBStatuses = data.databases;
|
|
syncDropdown(data.databases);
|
|
renderDBOverview(data.databases);
|
|
}
|
|
} catch (e) { /* silent */ }
|
|
}
|
|
|
|
// ---- Sync dropdown with available databases ----
|
|
function syncDropdown(databases) {
|
|
const currentOptions = new Set();
|
|
dbSelector.querySelectorAll('option').forEach(o => currentOptions.add(o.value));
|
|
|
|
const newNames = databases.map(db => db.name);
|
|
// Only rebuild if the options changed
|
|
if (newNames.length !== currentOptions.size || newNames.some(n => !currentOptions.has(n))) {
|
|
const savedValue = currentDB;
|
|
dbSelector.innerHTML = '';
|
|
databases.forEach(db => {
|
|
const opt = document.createElement('option');
|
|
opt.value = db.name;
|
|
opt.textContent = db.name;
|
|
dbSelector.appendChild(opt);
|
|
});
|
|
dbSelector.value = savedValue;
|
|
}
|
|
}
|
|
|
|
// ---- Render database overview cards ----
|
|
function renderDBOverview(databases) {
|
|
const grid = $('#db-overview-grid');
|
|
grid.innerHTML = '';
|
|
|
|
databases.forEach(db => {
|
|
const card = document.createElement('div');
|
|
card.className = 'db-overview-card' + (db.name === currentDB ? ' active' : '');
|
|
card.innerHTML = `
|
|
<div class="db-overview-dot ${db.status === 'UP' ? 'up' : 'down'}"></div>
|
|
<div class="db-overview-info">
|
|
<div class="db-overview-name">${db.name}</div>
|
|
<div class="db-overview-meta">
|
|
<span>${db.status === 'UP' ? '●' : '✕'} ${db.status}</span>
|
|
<span>⏱ ${db.latency_ms ? db.latency_ms.toFixed(0) + 'ms' : '—'}</span>
|
|
</div>
|
|
</div>
|
|
`;
|
|
card.addEventListener('click', () => {
|
|
currentDB = db.name;
|
|
dbSelector.value = db.name;
|
|
fetchMetrics();
|
|
refreshCharts();
|
|
updateOverviewHighlight();
|
|
});
|
|
grid.appendChild(card);
|
|
});
|
|
}
|
|
|
|
function updateOverviewHighlight() {
|
|
document.querySelectorAll('.db-overview-card').forEach((card, i) => {
|
|
if (allDBStatuses[i] && allDBStatuses[i].name === currentDB) {
|
|
card.classList.add('active');
|
|
} else {
|
|
card.classList.remove('active');
|
|
}
|
|
});
|
|
}
|
|
|
|
// ---- Fetch & render metrics ----
|
|
async function fetchMetrics() {
|
|
if (!currentDB) return;
|
|
|
|
try {
|
|
const res = await fetch(`/api/metrics/${encodeURIComponent(currentDB)}`);
|
|
if (!res.ok) return;
|
|
const m = await res.json();
|
|
renderMetrics(m);
|
|
updateTimestamp();
|
|
} catch (e) {
|
|
console.error('Fetch metrics error:', e);
|
|
}
|
|
}
|
|
|
|
function renderMetrics(m) {
|
|
// Status banner
|
|
const banner = $('#status-banner');
|
|
const statusIcon = $('#status-icon');
|
|
|
|
if (m.status === 'UP') {
|
|
banner.className = 'status-up';
|
|
statusIcon.innerHTML = `<svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
|
|
<path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/>
|
|
<polyline points="22 4 12 14.01 9 11.01"/>
|
|
</svg>`;
|
|
$('#status-label').textContent = m.database_name;
|
|
$('#status-detail').textContent = 'All systems operational';
|
|
} else {
|
|
banner.className = 'status-down';
|
|
statusIcon.innerHTML = `<svg width="28" height="28" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
|
|
<circle cx="12" cy="12" r="10"/>
|
|
<line x1="15" y1="9" x2="9" y2="15"/>
|
|
<line x1="9" y1="9" x2="15" y2="15"/>
|
|
</svg>`;
|
|
$('#status-label').textContent = m.database_name;
|
|
$('#status-detail').textContent = m.error || 'Connection failed';
|
|
}
|
|
|
|
// Status meta
|
|
animateValue('#latency-value', `${m.latency_ms.toFixed(1)} ms`);
|
|
animateValue('#version-value', formatVersion(m.version));
|
|
animateValue('#uptime-value', formatUptime(m.uptime_seconds));
|
|
|
|
// Connections card
|
|
animateValue('#conn-total', m.total_connections);
|
|
animateValue('#conn-active', m.active_connections);
|
|
animateValue('#conn-idle', m.idle_connections);
|
|
animateValue('#conn-max', m.max_connections);
|
|
|
|
const pct = m.connection_usage_pct || 0;
|
|
const fill = $('#conn-progress-fill');
|
|
fill.style.width = `${Math.min(pct, 100)}%`;
|
|
fill.className = 'progress-fill' + (pct > 80 ? ' danger' : pct > 60 ? ' warning' : '');
|
|
$('#conn-progress-text').textContent = `${pct.toFixed(0)}%`;
|
|
|
|
// Queries card
|
|
animateValue('#query-active', m.active_queries);
|
|
animateValue('#query-long', m.long_running_queries);
|
|
animateValue('#query-waiting', m.waiting_queries);
|
|
|
|
// Size card
|
|
animateValue('#db-size', m.database_size_human || formatBytes(m.database_size_bytes));
|
|
|
|
// Cache & transactions
|
|
animateValue('#cache-ratio', `${(m.cache_hit_ratio || 0).toFixed(1)}%`);
|
|
animateValue('#tx-commit', formatNumber(m.tx_commit));
|
|
animateValue('#tx-rollback', formatNumber(m.tx_rollback));
|
|
|
|
// Locks
|
|
animateValue('#locks-active', m.active_locks);
|
|
animateValue('#locks-waiting', m.waiting_locks);
|
|
animateValue('#locks-deadlocks', m.deadlocks);
|
|
|
|
// Row Activity
|
|
animateValue('#rows-fetched', formatNumber(m.tup_fetched));
|
|
animateValue('#rows-inserted', formatNumber(m.tup_inserted));
|
|
animateValue('#rows-updated', formatNumber(m.tup_updated));
|
|
animateValue('#rows-deleted', formatNumber(m.tup_deleted));
|
|
|
|
// Block I/O
|
|
animateValue('#io-hit', formatNumber(m.blks_hit));
|
|
animateValue('#io-read', formatNumber(m.blks_read));
|
|
animateValue('#io-tempfiles', formatNumber(m.temp_files));
|
|
animateValue('#io-tempbytes', formatBytes(m.temp_bytes));
|
|
|
|
// Replication
|
|
if (m.is_replica) {
|
|
animateValue('#repl-status', 'Replica');
|
|
$('#repl-label').textContent = 'Role';
|
|
animateValue('#repl-lag', `${m.replication_lag_ms.toFixed(0)} ms`);
|
|
} else {
|
|
animateValue('#repl-status', 'Primary');
|
|
$('#repl-label').textContent = 'Role';
|
|
animateValue('#repl-lag', 'N/A');
|
|
}
|
|
|
|
// Table Stats
|
|
renderTableStats(m.table_stats || []);
|
|
|
|
// Running Queries
|
|
renderRunningQueries(m.running_queries || []);
|
|
}
|
|
|
|
// ---- Render Table Stats ----
|
|
function renderTableStats(tables) {
|
|
const tbody = $('#table-stats-body');
|
|
if (!tables || tables.length === 0) {
|
|
tbody.innerHTML = '<tr><td colspan="5" class="empty-state">No user tables found</td></tr>';
|
|
return;
|
|
}
|
|
|
|
const maxSize = Math.max(...tables.map(t => t.size_bytes), 1);
|
|
|
|
tbody.innerHTML = tables.map(t => {
|
|
const pct = (t.size_bytes / maxSize * 100).toFixed(1);
|
|
return `<tr>
|
|
<td><strong>${t.schema_name}.${t.table_name}</strong></td>
|
|
<td>${t.size_human}</td>
|
|
<td class="hide-mobile">${formatNumber(t.row_estimate)}</td>
|
|
<td class="hide-mobile"><span class="${t.dead_tuples > 1000 ? 'danger-value' : ''}">${formatNumber(t.dead_tuples)}</span></td>
|
|
<td>
|
|
<div class="size-bar-wrap">
|
|
<div class="size-bar-outer">
|
|
<div class="size-bar-fill" style="width: ${pct}%"></div>
|
|
</div>
|
|
</div>
|
|
</td>
|
|
</tr>`;
|
|
}).join('');
|
|
}
|
|
|
|
// ---- Render Running Queries ----
|
|
function renderRunningQueries(queries) {
|
|
const tbody = $('#queries-body');
|
|
const badge = $('#running-queries-count');
|
|
badge.textContent = queries.length;
|
|
|
|
if (!queries || queries.length === 0) {
|
|
tbody.innerHTML = '<tr><td colspan="5" class="empty-state">No active queries</td></tr>';
|
|
return;
|
|
}
|
|
|
|
tbody.innerHTML = queries.map(q => {
|
|
const durClass = q.duration_ms > 300000 ? 'critical' : q.duration_ms > 60000 ? 'slow' : '';
|
|
const stateClass = q.state === 'active' ? 'active' : q.state === 'idle in transaction' ? 'waiting' : 'idle';
|
|
return `<tr>
|
|
<td><strong>${q.pid}</strong></td>
|
|
<td><span class="duration-value ${durClass}">${formatDuration(q.duration_ms)}</span></td>
|
|
<td><span class="state-badge ${stateClass}">${q.state}</span></td>
|
|
<td class="hide-mobile">${q.username || '—'}</td>
|
|
<td><span class="query-text" title="${escapeHtml(q.query)}">${escapeHtml(q.query)}</span></td>
|
|
</tr>`;
|
|
}).join('');
|
|
}
|
|
|
|
// ---- Charts ----
|
|
function initCharts() {
|
|
const defaultOptions = {
|
|
responsive: true,
|
|
maintainAspectRatio: false,
|
|
interaction: { intersect: false, mode: 'index' },
|
|
plugins: {
|
|
legend: {
|
|
display: true,
|
|
position: 'top',
|
|
labels: {
|
|
color: '#9ca3af',
|
|
font: { family: "'Inter', sans-serif", size: 11 },
|
|
boxWidth: 12,
|
|
padding: 16,
|
|
}
|
|
},
|
|
tooltip: {
|
|
backgroundColor: 'rgba(17, 24, 39, 0.95)',
|
|
titleFont: { family: "'Inter', sans-serif" },
|
|
bodyFont: { family: "'Inter', sans-serif" },
|
|
borderColor: 'rgba(99, 102, 241, 0.2)',
|
|
borderWidth: 1,
|
|
cornerRadius: 8,
|
|
padding: 12,
|
|
}
|
|
},
|
|
scales: {
|
|
x: {
|
|
grid: { color: 'rgba(255,255,255,0.04)' },
|
|
ticks: { color: '#6b7280', font: { size: 10 }, maxTicksLimit: 12 }
|
|
},
|
|
y: {
|
|
grid: { color: 'rgba(255,255,255,0.04)' },
|
|
ticks: { color: '#6b7280', font: { size: 10 } },
|
|
beginAtZero: true
|
|
}
|
|
},
|
|
elements: {
|
|
point: { radius: 0, hoverRadius: 5, hoverBorderWidth: 2 },
|
|
line: { tension: 0.3, borderWidth: 2 }
|
|
}
|
|
};
|
|
|
|
// Connections chart
|
|
charts.connections = new Chart($('#chart-connections'), {
|
|
type: 'line',
|
|
data: {
|
|
labels: [],
|
|
datasets: [
|
|
{
|
|
label: 'Active',
|
|
data: [],
|
|
borderColor: '#6366f1',
|
|
backgroundColor: 'rgba(99, 102, 241, 0.1)',
|
|
fill: true,
|
|
},
|
|
{
|
|
label: 'Total',
|
|
data: [],
|
|
borderColor: '#818cf8',
|
|
backgroundColor: 'rgba(129, 140, 248, 0.05)',
|
|
fill: true,
|
|
}
|
|
]
|
|
},
|
|
options: { ...defaultOptions }
|
|
});
|
|
|
|
// Cache hit ratio chart
|
|
charts.cache = new Chart($('#chart-cache'), {
|
|
type: 'line',
|
|
data: {
|
|
labels: [],
|
|
datasets: [{
|
|
label: 'Cache Hit %',
|
|
data: [],
|
|
borderColor: '#f59e0b',
|
|
backgroundColor: 'rgba(245, 158, 11, 0.1)',
|
|
fill: true,
|
|
}]
|
|
},
|
|
options: {
|
|
...defaultOptions,
|
|
scales: {
|
|
...defaultOptions.scales,
|
|
y: { ...defaultOptions.scales.y, max: 100, min: 0 }
|
|
}
|
|
}
|
|
});
|
|
|
|
// Latency chart
|
|
charts.latency = new Chart($('#chart-latency'), {
|
|
type: 'line',
|
|
data: {
|
|
labels: [],
|
|
datasets: [{
|
|
label: 'Latency (ms)',
|
|
data: [],
|
|
borderColor: '#06b6d4',
|
|
backgroundColor: 'rgba(6, 182, 212, 0.1)',
|
|
fill: true,
|
|
}]
|
|
},
|
|
options: { ...defaultOptions }
|
|
});
|
|
|
|
// Transaction throughput chart
|
|
charts.tps = new Chart($('#chart-tps'), {
|
|
type: 'line',
|
|
data: {
|
|
labels: [],
|
|
datasets: [
|
|
{
|
|
label: 'Commits',
|
|
data: [],
|
|
borderColor: '#10b981',
|
|
backgroundColor: 'rgba(16, 185, 129, 0.1)',
|
|
fill: true,
|
|
},
|
|
{
|
|
label: 'Rollbacks',
|
|
data: [],
|
|
borderColor: '#ef4444',
|
|
backgroundColor: 'rgba(239, 68, 68, 0.05)',
|
|
fill: true,
|
|
}
|
|
]
|
|
},
|
|
options: { ...defaultOptions }
|
|
});
|
|
|
|
// Database size chart
|
|
charts.dbsize = new Chart($('#chart-dbsize'), {
|
|
type: 'line',
|
|
data: {
|
|
labels: [],
|
|
datasets: [{
|
|
label: 'Size (bytes)',
|
|
data: [],
|
|
borderColor: '#8b5cf6',
|
|
backgroundColor: 'rgba(139, 92, 246, 0.1)',
|
|
fill: true,
|
|
}]
|
|
},
|
|
options: {
|
|
...defaultOptions,
|
|
scales: {
|
|
...defaultOptions.scales,
|
|
y: {
|
|
...defaultOptions.scales.y,
|
|
ticks: {
|
|
...defaultOptions.scales.y.ticks,
|
|
callback: (val) => formatBytes(val)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// Locks chart
|
|
charts.locks = new Chart($('#chart-locks'), {
|
|
type: 'line',
|
|
data: {
|
|
labels: [],
|
|
datasets: [
|
|
{
|
|
label: 'Active Locks',
|
|
data: [],
|
|
borderColor: '#ef4444',
|
|
backgroundColor: 'rgba(239, 68, 68, 0.1)',
|
|
fill: true,
|
|
},
|
|
{
|
|
label: 'Waiting',
|
|
data: [],
|
|
borderColor: '#f59e0b',
|
|
backgroundColor: 'rgba(245, 158, 11, 0.05)',
|
|
fill: true,
|
|
}
|
|
]
|
|
},
|
|
options: { ...defaultOptions }
|
|
});
|
|
|
|
// Queries chart
|
|
charts.queries = new Chart($('#chart-queries'), {
|
|
type: 'line',
|
|
data: {
|
|
labels: [],
|
|
datasets: [
|
|
{
|
|
label: 'Active Queries',
|
|
data: [],
|
|
borderColor: '#06b6d4',
|
|
backgroundColor: 'rgba(6, 182, 212, 0.1)',
|
|
fill: true,
|
|
},
|
|
{
|
|
label: 'Long Running',
|
|
data: [],
|
|
borderColor: '#ef4444',
|
|
backgroundColor: 'rgba(239, 68, 68, 0.05)',
|
|
fill: true,
|
|
}
|
|
]
|
|
},
|
|
options: { ...defaultOptions }
|
|
});
|
|
}
|
|
|
|
async function refreshCharts() {
|
|
if (!currentDB) return;
|
|
|
|
const chartConfigs = [
|
|
{
|
|
chart: 'connections',
|
|
controlParent: 0,
|
|
metrics: [
|
|
{ name: 'active_connections', dataset: 0 },
|
|
{ name: 'total_connections', dataset: 1 },
|
|
],
|
|
},
|
|
{
|
|
chart: 'cache',
|
|
controlParent: 1,
|
|
metrics: [
|
|
{ name: 'cache_hit_ratio', dataset: 0 },
|
|
],
|
|
},
|
|
{
|
|
chart: 'latency',
|
|
controlParent: 2,
|
|
metrics: [
|
|
{ name: 'latency_ms', dataset: 0 },
|
|
],
|
|
},
|
|
{
|
|
chart: 'tps',
|
|
controlParent: 3,
|
|
metrics: [
|
|
{ name: 'tx_commit', dataset: 0 },
|
|
{ name: 'tx_rollback', dataset: 1 },
|
|
],
|
|
},
|
|
{
|
|
chart: 'dbsize',
|
|
controlParent: 4,
|
|
metrics: [
|
|
{ name: 'database_size_bytes', dataset: 0 },
|
|
],
|
|
},
|
|
{
|
|
chart: 'locks',
|
|
controlParent: 5,
|
|
metrics: [
|
|
{ name: 'active_locks', dataset: 0 },
|
|
{ name: 'waiting_locks', dataset: 1 },
|
|
],
|
|
},
|
|
{
|
|
chart: 'queries',
|
|
controlParent: 6,
|
|
metrics: [
|
|
{ name: 'active_queries', dataset: 0 },
|
|
{ name: 'long_running_queries', dataset: 1 },
|
|
],
|
|
},
|
|
];
|
|
|
|
const controlGroups = document.querySelectorAll('.chart-controls');
|
|
|
|
for (const cfg of chartConfigs) {
|
|
const activeBtn = controlGroups[cfg.controlParent]?.querySelector('.chart-range.active');
|
|
const rangeMin = activeBtn ? parseInt(activeBtn.dataset.range) : 60;
|
|
|
|
for (const metric of cfg.metrics) {
|
|
try {
|
|
const res = await fetch(
|
|
`/api/history/${encodeURIComponent(currentDB)}/${metric.name}?range=${rangeMin}`
|
|
);
|
|
const data = await res.json();
|
|
|
|
if (data.points && data.points.length > 0) {
|
|
const labels = data.points.map(p => formatTime(p.timestamp));
|
|
const values = data.points.map(p => p.value);
|
|
|
|
charts[cfg.chart].data.labels = labels;
|
|
charts[cfg.chart].data.datasets[metric.dataset].data = values;
|
|
}
|
|
} catch (e) {
|
|
// silent
|
|
}
|
|
}
|
|
charts[cfg.chart].update('none');
|
|
}
|
|
}
|
|
|
|
// ---- Helpers ----
|
|
function animateValue(selector, value) {
|
|
const el = $(selector);
|
|
if (!el) return;
|
|
const strVal = value == null ? '—' : String(value);
|
|
if (el.textContent !== strVal) {
|
|
el.textContent = strVal;
|
|
el.classList.add('updating');
|
|
setTimeout(() => el.classList.remove('updating'), 400);
|
|
}
|
|
}
|
|
|
|
function updateTimestamp() {
|
|
const now = new Date();
|
|
lastUpdateEl.textContent = `Updated ${now.toLocaleTimeString()}`;
|
|
}
|
|
|
|
function formatVersion(v) {
|
|
if (!v) return '—';
|
|
const match = v.match(/PostgreSQL\s+(\d+\.\d+)/);
|
|
return match ? `PG ${match[1]}` : v.substring(0, 20);
|
|
}
|
|
|
|
function formatUptime(seconds) {
|
|
if (!seconds || seconds <= 0) return '—';
|
|
const d = Math.floor(seconds / 86400);
|
|
const h = Math.floor((seconds % 86400) / 3600);
|
|
const m = Math.floor((seconds % 3600) / 60);
|
|
if (d > 0) return `${d}d ${h}h`;
|
|
if (h > 0) return `${h}h ${m}m`;
|
|
return `${m}m`;
|
|
}
|
|
|
|
function formatBytes(bytes) {
|
|
if (!bytes || bytes <= 0) return '0 B';
|
|
const units = ['B', 'KB', 'MB', 'GB', 'TB'];
|
|
let i = 0;
|
|
let val = bytes;
|
|
while (val >= 1024 && i < units.length - 1) {
|
|
val /= 1024;
|
|
i++;
|
|
}
|
|
return `${val.toFixed(1)} ${units[i]}`;
|
|
}
|
|
|
|
function formatNumber(n) {
|
|
if (n == null) return '—';
|
|
if (n >= 1_000_000_000) return `${(n / 1_000_000_000).toFixed(1)}B`;
|
|
if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`;
|
|
if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`;
|
|
return String(n);
|
|
}
|
|
|
|
function formatTime(ts) {
|
|
const d = new Date(ts * 1000);
|
|
return d.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
|
|
}
|
|
|
|
function formatDuration(ms) {
|
|
if (ms < 1000) return `${ms.toFixed(0)}ms`;
|
|
if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
|
|
if (ms < 3600000) return `${(ms / 60000).toFixed(1)}m`;
|
|
return `${(ms / 3600000).toFixed(1)}h`;
|
|
}
|
|
|
|
function escapeHtml(str) {
|
|
if (!str) return '';
|
|
return str.replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"');
|
|
}
|
|
|
|
})();
|