Files
2026-10-30 16:35:46 +02:00

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, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
}
})();