mirror of
https://github.com/Kpa-clawbot/meshcore-analyzer.git
synced 2026-03-30 17:05:58 +00:00
676 lines
25 KiB
JavaScript
676 lines
25 KiB
JavaScript
const Database = require('better-sqlite3');
|
|
const path = require('path');
|
|
const fs = require('fs');
|
|
|
|
// Ensure data directory exists
|
|
const dbPath = process.env.DB_PATH || path.join(__dirname, 'data', 'meshcore.db');
|
|
const dataDir = path.dirname(dbPath);
|
|
if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
|
|
|
|
const db = new Database(dbPath);
|
|
db.pragma('journal_mode = WAL');
|
|
db.pragma('foreign_keys = ON');
|
|
|
|
// --- Schema ---
|
|
db.exec(`
|
|
CREATE TABLE IF NOT EXISTS packets (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
raw_hex TEXT NOT NULL,
|
|
timestamp TEXT NOT NULL,
|
|
observer_id TEXT,
|
|
observer_name TEXT,
|
|
direction TEXT,
|
|
snr REAL,
|
|
rssi REAL,
|
|
score INTEGER,
|
|
hash TEXT,
|
|
route_type INTEGER,
|
|
payload_type INTEGER,
|
|
payload_version INTEGER,
|
|
path_json TEXT,
|
|
decoded_json TEXT,
|
|
created_at TEXT DEFAULT (datetime('now'))
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS nodes (
|
|
public_key TEXT PRIMARY KEY,
|
|
name TEXT,
|
|
role TEXT,
|
|
lat REAL,
|
|
lon REAL,
|
|
last_seen TEXT,
|
|
first_seen TEXT,
|
|
advert_count INTEGER DEFAULT 0
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS observers (
|
|
id TEXT PRIMARY KEY,
|
|
name TEXT,
|
|
iata TEXT,
|
|
last_seen TEXT,
|
|
first_seen TEXT,
|
|
packet_count INTEGER DEFAULT 0,
|
|
model TEXT,
|
|
firmware TEXT,
|
|
client_version TEXT,
|
|
radio TEXT,
|
|
battery_mv INTEGER,
|
|
uptime_secs INTEGER,
|
|
noise_floor INTEGER
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS paths (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
packet_id INTEGER REFERENCES packets(id),
|
|
hop_index INTEGER,
|
|
node_hash TEXT
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_packets_timestamp ON packets(timestamp);
|
|
CREATE INDEX IF NOT EXISTS idx_packets_hash ON packets(hash);
|
|
CREATE INDEX IF NOT EXISTS idx_packets_payload_type ON packets(payload_type);
|
|
CREATE INDEX IF NOT EXISTS idx_nodes_last_seen ON nodes(last_seen);
|
|
CREATE INDEX IF NOT EXISTS idx_observers_last_seen ON observers(last_seen);
|
|
|
|
CREATE TABLE IF NOT EXISTS transmissions (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
raw_hex TEXT NOT NULL,
|
|
hash TEXT NOT NULL UNIQUE,
|
|
first_seen TEXT NOT NULL,
|
|
route_type INTEGER,
|
|
payload_type INTEGER,
|
|
payload_version INTEGER,
|
|
decoded_json TEXT,
|
|
created_at TEXT DEFAULT (datetime('now'))
|
|
);
|
|
|
|
CREATE TABLE IF NOT EXISTS observations (
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,
|
|
transmission_id INTEGER NOT NULL REFERENCES transmissions(id),
|
|
hash TEXT NOT NULL,
|
|
observer_id TEXT,
|
|
observer_name TEXT,
|
|
direction TEXT,
|
|
snr REAL,
|
|
rssi REAL,
|
|
score INTEGER,
|
|
path_json TEXT,
|
|
timestamp TEXT NOT NULL,
|
|
created_at TEXT DEFAULT (datetime('now'))
|
|
);
|
|
|
|
CREATE INDEX IF NOT EXISTS idx_transmissions_hash ON transmissions(hash);
|
|
CREATE INDEX IF NOT EXISTS idx_transmissions_first_seen ON transmissions(first_seen);
|
|
CREATE INDEX IF NOT EXISTS idx_transmissions_payload_type ON transmissions(payload_type);
|
|
CREATE INDEX IF NOT EXISTS idx_observations_hash ON observations(hash);
|
|
CREATE INDEX IF NOT EXISTS idx_observations_transmission_id ON observations(transmission_id);
|
|
CREATE INDEX IF NOT EXISTS idx_observations_observer_id ON observations(observer_id);
|
|
CREATE INDEX IF NOT EXISTS idx_observations_timestamp ON observations(timestamp);
|
|
CREATE UNIQUE INDEX IF NOT EXISTS idx_observations_dedup ON observations(hash, observer_id, path_json);
|
|
`);
|
|
|
|
// --- Migrations for existing DBs ---
|
|
const observerCols = db.pragma('table_info(observers)').map(c => c.name);
|
|
for (const col of ['model', 'firmware', 'client_version', 'radio', 'battery_mv', 'uptime_secs', 'noise_floor']) {
|
|
if (!observerCols.includes(col)) {
|
|
const type = ['battery_mv', 'uptime_secs', 'noise_floor'].includes(col) ? 'INTEGER' : 'TEXT';
|
|
db.exec(`ALTER TABLE observers ADD COLUMN ${col} ${type}`);
|
|
console.log(`[migration] Added observers.${col}`);
|
|
}
|
|
}
|
|
|
|
// --- Cleanup corrupted nodes on startup ---
|
|
// Remove nodes with obviously invalid data (short pubkeys, control chars in names, etc.)
|
|
{
|
|
const cleaned = db.prepare(`
|
|
DELETE FROM nodes WHERE
|
|
length(public_key) < 16
|
|
OR public_key GLOB '*[^0-9a-fA-F]*'
|
|
OR (lat IS NOT NULL AND (lat < -90 OR lat > 90))
|
|
OR (lon IS NOT NULL AND (lon < -180 OR lon > 180))
|
|
`).run();
|
|
if (cleaned.changes > 0) console.log(`[cleanup] Removed ${cleaned.changes} corrupted node(s) from DB`);
|
|
}
|
|
|
|
// --- Prepared statements ---
|
|
const stmts = {
|
|
insertPacket: db.prepare(`
|
|
INSERT INTO packets (raw_hex, timestamp, observer_id, observer_name, direction, snr, rssi, score, hash, route_type, payload_type, payload_version, path_json, decoded_json)
|
|
VALUES (@raw_hex, @timestamp, @observer_id, @observer_name, @direction, @snr, @rssi, @score, @hash, @route_type, @payload_type, @payload_version, @path_json, @decoded_json)
|
|
`),
|
|
insertPath: db.prepare(`INSERT INTO paths (packet_id, hop_index, node_hash) VALUES (?, ?, ?)`),
|
|
upsertNode: db.prepare(`
|
|
INSERT INTO nodes (public_key, name, role, lat, lon, last_seen, first_seen, advert_count)
|
|
VALUES (@public_key, @name, @role, @lat, @lon, @last_seen, @first_seen, 1)
|
|
ON CONFLICT(public_key) DO UPDATE SET
|
|
name = COALESCE(@name, name),
|
|
role = COALESCE(@role, role),
|
|
lat = COALESCE(@lat, lat),
|
|
lon = COALESCE(@lon, lon),
|
|
last_seen = @last_seen,
|
|
advert_count = advert_count + 1
|
|
`),
|
|
upsertObserver: db.prepare(`
|
|
INSERT INTO observers (id, name, iata, last_seen, first_seen, packet_count, model, firmware, client_version, radio, battery_mv, uptime_secs, noise_floor)
|
|
VALUES (@id, @name, @iata, @last_seen, @first_seen, 1, @model, @firmware, @client_version, @radio, @battery_mv, @uptime_secs, @noise_floor)
|
|
ON CONFLICT(id) DO UPDATE SET
|
|
name = COALESCE(@name, name),
|
|
iata = COALESCE(@iata, iata),
|
|
last_seen = @last_seen,
|
|
packet_count = packet_count + 1,
|
|
model = COALESCE(@model, model),
|
|
firmware = COALESCE(@firmware, firmware),
|
|
client_version = COALESCE(@client_version, client_version),
|
|
radio = COALESCE(@radio, radio),
|
|
battery_mv = COALESCE(@battery_mv, battery_mv),
|
|
uptime_secs = COALESCE(@uptime_secs, uptime_secs),
|
|
noise_floor = COALESCE(@noise_floor, noise_floor)
|
|
`),
|
|
updateObserverStatus: db.prepare(`
|
|
INSERT INTO observers (id, name, iata, last_seen, first_seen, packet_count, model, firmware, client_version, radio, battery_mv, uptime_secs, noise_floor)
|
|
VALUES (@id, @name, @iata, @last_seen, @first_seen, 0, @model, @firmware, @client_version, @radio, @battery_mv, @uptime_secs, @noise_floor)
|
|
ON CONFLICT(id) DO UPDATE SET
|
|
name = COALESCE(@name, name),
|
|
iata = COALESCE(@iata, iata),
|
|
last_seen = @last_seen,
|
|
model = COALESCE(@model, model),
|
|
firmware = COALESCE(@firmware, firmware),
|
|
client_version = COALESCE(@client_version, client_version),
|
|
radio = COALESCE(@radio, radio),
|
|
battery_mv = COALESCE(@battery_mv, battery_mv),
|
|
uptime_secs = COALESCE(@uptime_secs, uptime_secs),
|
|
noise_floor = COALESCE(@noise_floor, noise_floor)
|
|
`),
|
|
getPacket: db.prepare(`SELECT * FROM packets WHERE id = ?`),
|
|
getPathsForPacket: db.prepare(`SELECT * FROM paths WHERE packet_id = ? ORDER BY hop_index`),
|
|
getNode: db.prepare(`SELECT * FROM nodes WHERE public_key = ?`),
|
|
getRecentPacketsForNode: db.prepare(`
|
|
SELECT * FROM packets WHERE decoded_json LIKE ? OR decoded_json LIKE ? OR decoded_json LIKE ? OR decoded_json LIKE ?
|
|
ORDER BY timestamp DESC LIMIT 20
|
|
`),
|
|
getObservers: db.prepare(`SELECT * FROM observers ORDER BY last_seen DESC`),
|
|
countPackets: db.prepare(`SELECT COUNT(*) as count FROM packets`),
|
|
countNodes: db.prepare(`SELECT COUNT(*) as count FROM nodes`),
|
|
countObservers: db.prepare(`SELECT COUNT(*) as count FROM observers`),
|
|
countRecentPackets: db.prepare(`SELECT COUNT(*) as count FROM packets WHERE timestamp > ?`),
|
|
getTransmissionByHash: db.prepare(`SELECT id, first_seen FROM transmissions WHERE hash = ?`),
|
|
insertTransmission: db.prepare(`
|
|
INSERT INTO transmissions (raw_hex, hash, first_seen, route_type, payload_type, payload_version, decoded_json)
|
|
VALUES (@raw_hex, @hash, @first_seen, @route_type, @payload_type, @payload_version, @decoded_json)
|
|
`),
|
|
updateTransmissionFirstSeen: db.prepare(`UPDATE transmissions SET first_seen = @first_seen WHERE id = @id`),
|
|
insertObservation: db.prepare(`
|
|
INSERT OR IGNORE INTO observations (transmission_id, hash, observer_id, observer_name, direction, snr, rssi, score, path_json, timestamp)
|
|
VALUES (@transmission_id, @hash, @observer_id, @observer_name, @direction, @snr, @rssi, @score, @path_json, @timestamp)
|
|
`),
|
|
};
|
|
|
|
// --- Helper functions ---
|
|
|
|
function insertPacket(data) {
|
|
const d = {
|
|
raw_hex: data.raw_hex,
|
|
timestamp: data.timestamp || new Date().toISOString(),
|
|
observer_id: data.observer_id || null,
|
|
observer_name: data.observer_name || null,
|
|
direction: data.direction || null,
|
|
snr: data.snr ?? null,
|
|
rssi: data.rssi ?? null,
|
|
score: data.score ?? null,
|
|
hash: data.hash || null,
|
|
route_type: data.route_type ?? null,
|
|
payload_type: data.payload_type ?? null,
|
|
payload_version: data.payload_version ?? null,
|
|
path_json: data.path_json || null,
|
|
decoded_json: data.decoded_json || null,
|
|
};
|
|
return stmts.insertPacket.run(d).lastInsertRowid;
|
|
}
|
|
|
|
function insertTransmission(data) {
|
|
const hash = data.hash;
|
|
if (!hash) return null; // Can't deduplicate without a hash
|
|
|
|
const timestamp = data.timestamp || new Date().toISOString();
|
|
let transmissionId;
|
|
|
|
const existing = stmts.getTransmissionByHash.get(hash);
|
|
if (existing) {
|
|
transmissionId = existing.id;
|
|
// Update first_seen if this observation is earlier
|
|
if (timestamp < existing.first_seen) {
|
|
stmts.updateTransmissionFirstSeen.run({ id: transmissionId, first_seen: timestamp });
|
|
}
|
|
} else {
|
|
const result = stmts.insertTransmission.run({
|
|
raw_hex: data.raw_hex || '',
|
|
hash,
|
|
first_seen: timestamp,
|
|
route_type: data.route_type ?? null,
|
|
payload_type: data.payload_type ?? null,
|
|
payload_version: data.payload_version ?? null,
|
|
decoded_json: data.decoded_json || null,
|
|
});
|
|
transmissionId = result.lastInsertRowid;
|
|
}
|
|
|
|
const obsResult = stmts.insertObservation.run({
|
|
transmission_id: transmissionId,
|
|
hash,
|
|
observer_id: data.observer_id || null,
|
|
observer_name: data.observer_name || null,
|
|
direction: data.direction || null,
|
|
snr: data.snr ?? null,
|
|
rssi: data.rssi ?? null,
|
|
score: data.score ?? null,
|
|
path_json: data.path_json || null,
|
|
timestamp,
|
|
});
|
|
|
|
return { transmissionId, observationId: obsResult.lastInsertRowid };
|
|
}
|
|
|
|
function insertPath(packetId, hops) {
|
|
const tx = db.transaction((hops) => {
|
|
for (let i = 0; i < hops.length; i++) {
|
|
stmts.insertPath.run(packetId, i, hops[i]);
|
|
}
|
|
});
|
|
tx(hops);
|
|
}
|
|
|
|
function upsertNode(data) {
|
|
const now = new Date().toISOString();
|
|
stmts.upsertNode.run({
|
|
public_key: data.public_key,
|
|
name: data.name || null,
|
|
role: data.role || null,
|
|
lat: data.lat ?? null,
|
|
lon: data.lon ?? null,
|
|
last_seen: data.last_seen || now,
|
|
first_seen: data.first_seen || now,
|
|
});
|
|
}
|
|
|
|
function upsertObserver(data) {
|
|
const now = new Date().toISOString();
|
|
stmts.upsertObserver.run({
|
|
id: data.id,
|
|
name: data.name || null,
|
|
iata: data.iata || null,
|
|
last_seen: data.last_seen || now,
|
|
first_seen: data.first_seen || now,
|
|
model: data.model || null,
|
|
firmware: data.firmware || null,
|
|
client_version: data.client_version || null,
|
|
radio: data.radio || null,
|
|
battery_mv: data.battery_mv || null,
|
|
uptime_secs: data.uptime_secs || null,
|
|
noise_floor: data.noise_floor || null,
|
|
});
|
|
}
|
|
|
|
function updateObserverStatus(data) {
|
|
const now = new Date().toISOString();
|
|
stmts.updateObserverStatus.run({
|
|
id: data.id,
|
|
name: data.name || null,
|
|
iata: data.iata || null,
|
|
last_seen: data.last_seen || now,
|
|
first_seen: data.first_seen || now,
|
|
model: data.model || null,
|
|
firmware: data.firmware || null,
|
|
client_version: data.client_version || null,
|
|
radio: data.radio || null,
|
|
battery_mv: data.battery_mv || null,
|
|
uptime_secs: data.uptime_secs || null,
|
|
noise_floor: data.noise_floor || null,
|
|
});
|
|
}
|
|
|
|
function getPackets({ limit = 50, offset = 0, type, route, hash, since } = {}) {
|
|
let where = [];
|
|
let params = {};
|
|
if (type !== undefined) { where.push('payload_type = @type'); params.type = type; }
|
|
if (route !== undefined) { where.push('route_type = @route'); params.route = route; }
|
|
if (hash) { where.push('hash = @hash'); params.hash = hash; }
|
|
if (since) { where.push('timestamp > @since'); params.since = since; }
|
|
const clause = where.length ? 'WHERE ' + where.join(' AND ') : '';
|
|
const rows = db.prepare(`SELECT * FROM packets ${clause} ORDER BY timestamp DESC LIMIT @limit OFFSET @offset`).all({ ...params, limit, offset });
|
|
const total = db.prepare(`SELECT COUNT(*) as count FROM packets ${clause}`).get(params).count;
|
|
return { rows, total };
|
|
}
|
|
|
|
function getTransmission(id) {
|
|
try {
|
|
return db.prepare('SELECT * FROM transmissions WHERE id = ?').get(id) || null;
|
|
} catch { return null; }
|
|
}
|
|
|
|
function getPacket(id) {
|
|
const packet = stmts.getPacket.get(id);
|
|
if (!packet) return null;
|
|
packet.paths = stmts.getPathsForPacket.all(id);
|
|
return packet;
|
|
}
|
|
|
|
function getNodes({ limit = 50, offset = 0, sortBy = 'last_seen' } = {}) {
|
|
const allowed = ['last_seen', 'name', 'advert_count', 'first_seen'];
|
|
const col = allowed.includes(sortBy) ? sortBy : 'last_seen';
|
|
const dir = col === 'name' ? 'ASC' : 'DESC';
|
|
const rows = db.prepare(`SELECT * FROM nodes ORDER BY ${col} ${dir} LIMIT ? OFFSET ?`).all(limit, offset);
|
|
const total = stmts.countNodes.get().count;
|
|
return { rows, total };
|
|
}
|
|
|
|
function getNode(pubkey) {
|
|
const node = stmts.getNode.get(pubkey);
|
|
if (!node) return null;
|
|
// Match by: pubkey anywhere, name in sender/text fields, name as text prefix ("Name: msg")
|
|
const namePattern = node.name ? `%${node.name}%` : `%${pubkey}%`;
|
|
const textPrefix = node.name ? `%"text":"${node.name}:%` : `%${pubkey}%`;
|
|
node.recentPackets = stmts.getRecentPacketsForNode.all(
|
|
`%${pubkey}%`,
|
|
namePattern,
|
|
textPrefix,
|
|
`%"sender":"${node.name || pubkey}"%`
|
|
);
|
|
return node;
|
|
}
|
|
|
|
function getObservers() {
|
|
return stmts.getObservers.all();
|
|
}
|
|
|
|
function getStats() {
|
|
const oneHourAgo = new Date(Date.now() - 3600000).toISOString();
|
|
// Try to get transmission count from normalized schema
|
|
let totalTransmissions = null;
|
|
try {
|
|
totalTransmissions = db.prepare('SELECT COUNT(*) as count FROM transmissions').get().count;
|
|
} catch {}
|
|
return {
|
|
totalPackets: stmts.countPackets.get().count,
|
|
totalTransmissions,
|
|
totalObservations: stmts.countPackets.get().count, // legacy packets = observations
|
|
totalNodes: stmts.countNodes.get().count,
|
|
totalObservers: stmts.countObservers.get().count,
|
|
packetsLastHour: stmts.countRecentPackets.get(oneHourAgo).count,
|
|
};
|
|
}
|
|
|
|
function seed() {
|
|
if (stmts.countPackets.get().count > 0) return false;
|
|
const now = new Date().toISOString();
|
|
const rawHex = '11451000D818206D3AAC152C8A91F89957E6D30CA51F36E28790228971C473B755F244F718754CF5EE4A2FD58D944466E42CDED140C66D0CC590183E32BAF40F112BE8F3F2BDF6012B4B2793C52F1D36F69EE054D9A05593286F78453E56C0EC4A3EB95DDA2A7543FCCC00B939CACC009278603902FC12BCF84B706120526F6F6620536F6C6172';
|
|
|
|
upsertObserver({ id: 'obs-seed-001', name: 'Seed Observer', iata: 'UNK', last_seen: now, first_seen: now });
|
|
|
|
const pktId = insertPacket({
|
|
raw_hex: rawHex,
|
|
timestamp: now,
|
|
observer_id: 'obs-seed-001',
|
|
observer_name: 'Seed Observer',
|
|
direction: 'rx',
|
|
snr: 10.5,
|
|
rssi: -85,
|
|
score: 42,
|
|
hash: 'seed-test-hash',
|
|
route_type: 1,
|
|
payload_type: 4,
|
|
payload_version: 1,
|
|
path_json: JSON.stringify(['A1B2', 'C3D4']),
|
|
decoded_json: JSON.stringify({ type: 'ADVERT', name: 'Test Repeater', role: 'repeater', lat: 0, lon: 0 }),
|
|
});
|
|
|
|
insertPath(pktId, ['A1B2', 'C3D4']);
|
|
|
|
upsertNode({
|
|
public_key: 'seed-test-pubkey',
|
|
name: 'Test Repeater',
|
|
role: 'repeater',
|
|
lat: 0,
|
|
lon: 0,
|
|
last_seen: now,
|
|
first_seen: now,
|
|
});
|
|
|
|
return true;
|
|
}
|
|
|
|
// --- Run directly ---
|
|
if (require.main === module) {
|
|
const seeded = seed();
|
|
console.log(seeded ? 'Database seeded with test data.' : 'Database already has data, skipping seed.');
|
|
console.log('Stats:', getStats());
|
|
}
|
|
|
|
function searchNodes(query, limit = 10) {
|
|
return db.prepare(`
|
|
SELECT * FROM nodes
|
|
WHERE name LIKE @q OR public_key LIKE @prefix
|
|
ORDER BY last_seen DESC
|
|
LIMIT @limit
|
|
`).all({ q: `%${query}%`, prefix: `${query}%`, limit });
|
|
}
|
|
|
|
function getNodeHealth(pubkey) {
|
|
const node = stmts.getNode.get(pubkey);
|
|
if (!node) return null;
|
|
|
|
const todayStart = new Date();
|
|
todayStart.setUTCHours(0, 0, 0, 0);
|
|
const todayISO = todayStart.toISOString();
|
|
|
|
const keyPattern = `%${pubkey}%`;
|
|
// Also match by node name in decoded_json (channel messages have sender name, not pubkey)
|
|
const namePattern = node.name ? `%${node.name.replace(/[%_]/g, '')}%` : null;
|
|
const whereClause = namePattern
|
|
? `(decoded_json LIKE @keyPattern OR decoded_json LIKE @namePattern)`
|
|
: `decoded_json LIKE @keyPattern`;
|
|
const params = namePattern ? { keyPattern, namePattern } : { keyPattern };
|
|
|
|
// Observers that heard this node
|
|
const observers = db.prepare(`
|
|
SELECT observer_id, observer_name,
|
|
AVG(snr) as avgSnr, AVG(rssi) as avgRssi, COUNT(*) as packetCount
|
|
FROM packets
|
|
WHERE ${whereClause} AND observer_id IS NOT NULL
|
|
GROUP BY observer_id
|
|
ORDER BY packetCount DESC
|
|
`).all(params);
|
|
|
|
// Stats
|
|
const packetsToday = db.prepare(`
|
|
SELECT COUNT(*) as count FROM packets WHERE ${whereClause} AND timestamp > @since
|
|
`).get({ ...params, since: todayISO }).count;
|
|
|
|
const avgStats = db.prepare(`
|
|
SELECT AVG(snr) as avgSnr FROM packets WHERE ${whereClause}
|
|
`).get(params);
|
|
|
|
const lastHeard = db.prepare(`
|
|
SELECT MAX(timestamp) as lastHeard FROM packets WHERE ${whereClause}
|
|
`).get(params).lastHeard;
|
|
|
|
// Avg hops from path_json
|
|
const pathRows = db.prepare(`
|
|
SELECT path_json FROM packets WHERE ${whereClause} AND path_json IS NOT NULL
|
|
`).all(params);
|
|
|
|
let totalHops = 0, hopCount = 0;
|
|
for (const row of pathRows) {
|
|
try {
|
|
const hops = JSON.parse(row.path_json);
|
|
if (Array.isArray(hops)) { totalHops += hops.length; hopCount++; }
|
|
} catch {}
|
|
}
|
|
const avgHops = hopCount > 0 ? Math.round(totalHops / hopCount) : 0;
|
|
|
|
const totalPackets = db.prepare(`
|
|
SELECT COUNT(*) as count FROM packets WHERE ${whereClause}
|
|
`).get(params).count;
|
|
|
|
// Recent 10 packets
|
|
const recentPackets = db.prepare(`
|
|
SELECT * FROM packets WHERE ${whereClause} ORDER BY timestamp DESC LIMIT 10
|
|
`).all(params);
|
|
|
|
return {
|
|
node,
|
|
observers,
|
|
stats: { totalPackets, packetsToday, avgSnr: avgStats.avgSnr, avgHops, lastHeard },
|
|
recentPackets,
|
|
};
|
|
}
|
|
|
|
function getNodeAnalytics(pubkey, days) {
|
|
const node = stmts.getNode.get(pubkey);
|
|
if (!node) return null;
|
|
|
|
const now = new Date();
|
|
const from = new Date(now.getTime() - days * 86400000);
|
|
const fromISO = from.toISOString();
|
|
const toISO = now.toISOString();
|
|
|
|
const keyPattern = `%${pubkey}%`;
|
|
const namePattern = node.name ? `%${node.name.replace(/[%_]/g, '')}%` : null;
|
|
const whereClause = namePattern
|
|
? `(decoded_json LIKE @keyPattern OR decoded_json LIKE @namePattern)`
|
|
: `decoded_json LIKE @keyPattern`;
|
|
const timeWhere = `${whereClause} AND timestamp > @fromISO`;
|
|
const params = namePattern ? { keyPattern, namePattern, fromISO } : { keyPattern, fromISO };
|
|
|
|
// Activity timeline
|
|
const activityTimeline = db.prepare(`
|
|
SELECT strftime('%Y-%m-%dT%H:00:00Z', timestamp) as bucket, COUNT(*) as count
|
|
FROM packets WHERE ${timeWhere} GROUP BY bucket ORDER BY bucket
|
|
`).all(params);
|
|
|
|
// SNR trend
|
|
const snrTrend = db.prepare(`
|
|
SELECT timestamp, snr, rssi, observer_id, observer_name
|
|
FROM packets WHERE ${timeWhere} AND snr IS NOT NULL ORDER BY timestamp
|
|
`).all(params);
|
|
|
|
// Packet type breakdown
|
|
const packetTypeBreakdown = db.prepare(`
|
|
SELECT payload_type, COUNT(*) as count FROM packets WHERE ${timeWhere} GROUP BY payload_type
|
|
`).all(params);
|
|
|
|
// Observer coverage
|
|
const observerCoverage = db.prepare(`
|
|
SELECT observer_id, observer_name, COUNT(*) as packetCount,
|
|
AVG(snr) as avgSnr, AVG(rssi) as avgRssi, MIN(timestamp) as firstSeen, MAX(timestamp) as lastSeen
|
|
FROM packets WHERE ${timeWhere} AND observer_id IS NOT NULL
|
|
GROUP BY observer_id ORDER BY packetCount DESC
|
|
`).all(params);
|
|
|
|
// Hop distribution
|
|
const pathRows = db.prepare(`
|
|
SELECT path_json FROM packets WHERE ${timeWhere} AND path_json IS NOT NULL
|
|
`).all(params);
|
|
|
|
const hopCounts = {};
|
|
let totalWithPath = 0, relayedCount = 0;
|
|
for (const row of pathRows) {
|
|
try {
|
|
const hops = JSON.parse(row.path_json);
|
|
if (Array.isArray(hops)) {
|
|
const h = hops.length;
|
|
const key = h >= 4 ? '4+' : String(h);
|
|
hopCounts[key] = (hopCounts[key] || 0) + 1;
|
|
totalWithPath++;
|
|
if (h > 1) relayedCount++;
|
|
}
|
|
} catch {}
|
|
}
|
|
const hopDistribution = Object.entries(hopCounts).map(([hops, count]) => ({ hops, count }))
|
|
.sort((a, b) => a.hops.localeCompare(b.hops, undefined, { numeric: true }));
|
|
|
|
// Peer interactions from decoded_json
|
|
const decodedRows = db.prepare(`
|
|
SELECT decoded_json, timestamp FROM packets WHERE ${timeWhere} AND decoded_json IS NOT NULL
|
|
`).all(params);
|
|
|
|
const peerMap = {};
|
|
for (const row of decodedRows) {
|
|
try {
|
|
const d = JSON.parse(row.decoded_json);
|
|
// Look for sender/recipient pubkeys that aren't this node
|
|
const candidates = [];
|
|
if (d.sender_key && d.sender_key !== pubkey) candidates.push({ key: d.sender_key, name: d.sender_name || d.sender_short_name });
|
|
if (d.recipient_key && d.recipient_key !== pubkey) candidates.push({ key: d.recipient_key, name: d.recipient_name || d.recipient_short_name });
|
|
if (d.pubkey && d.pubkey !== pubkey) candidates.push({ key: d.pubkey, name: d.name });
|
|
for (const c of candidates) {
|
|
if (!c.key) continue;
|
|
if (!peerMap[c.key]) peerMap[c.key] = { peer_key: c.key, peer_name: c.name || c.key.slice(0, 12), messageCount: 0, lastContact: row.timestamp };
|
|
peerMap[c.key].messageCount++;
|
|
if (row.timestamp > peerMap[c.key].lastContact) peerMap[c.key].lastContact = row.timestamp;
|
|
}
|
|
} catch {}
|
|
}
|
|
const peerInteractions = Object.values(peerMap).sort((a, b) => b.messageCount - a.messageCount).slice(0, 20);
|
|
|
|
// Uptime heatmap
|
|
const uptimeHeatmap = db.prepare(`
|
|
SELECT CAST(strftime('%w', timestamp) AS INTEGER) as dayOfWeek,
|
|
CAST(strftime('%H', timestamp) AS INTEGER) as hour, COUNT(*) as count
|
|
FROM packets WHERE ${timeWhere} GROUP BY dayOfWeek, hour
|
|
`).all(params);
|
|
|
|
// Computed stats
|
|
const totalPackets = db.prepare(`SELECT COUNT(*) as count FROM packets WHERE ${timeWhere}`).get(params).count;
|
|
const uniqueObservers = observerCoverage.length;
|
|
const uniquePeers = peerInteractions.length;
|
|
const avgPacketsPerDay = days > 0 ? Math.round(totalPackets / days * 10) / 10 : totalPackets;
|
|
|
|
// Availability: distinct hours with packets / total hours
|
|
const distinctHours = activityTimeline.length;
|
|
const totalHours = days * 24;
|
|
const availabilityPct = totalHours > 0 ? Math.round(distinctHours / totalHours * 1000) / 10 : 0;
|
|
|
|
// Longest silence
|
|
const timestamps = db.prepare(`
|
|
SELECT timestamp FROM packets WHERE ${timeWhere} ORDER BY timestamp
|
|
`).all(params).map(r => new Date(r.timestamp).getTime());
|
|
|
|
let longestSilenceMs = 0, longestSilenceStart = null;
|
|
for (let i = 1; i < timestamps.length; i++) {
|
|
const gap = timestamps[i] - timestamps[i - 1];
|
|
if (gap > longestSilenceMs) { longestSilenceMs = gap; longestSilenceStart = new Date(timestamps[i - 1]).toISOString(); }
|
|
}
|
|
|
|
// Signal grade
|
|
const snrValues = snrTrend.map(r => r.snr);
|
|
const snrMean = snrValues.length > 0 ? snrValues.reduce((a, b) => a + b, 0) / snrValues.length : 0;
|
|
const snrStdDev = snrValues.length > 1 ? Math.sqrt(snrValues.reduce((s, v) => s + (v - snrMean) ** 2, 0) / snrValues.length) : 0;
|
|
let signalGrade = 'D';
|
|
if (snrMean > 15 && snrStdDev < 2) signalGrade = 'A';
|
|
else if (snrMean > 15) signalGrade = 'A-';
|
|
else if (snrMean > 12 && snrStdDev < 3) signalGrade = 'B+';
|
|
else if (snrMean > 8) signalGrade = 'B';
|
|
else if (snrMean > 3) signalGrade = 'C';
|
|
|
|
const relayPct = totalWithPath > 0 ? Math.round(relayedCount / totalWithPath * 1000) / 10 : 0;
|
|
|
|
return {
|
|
node,
|
|
timeRange: { from: fromISO, to: toISO, days },
|
|
activityTimeline,
|
|
snrTrend,
|
|
packetTypeBreakdown,
|
|
observerCoverage,
|
|
hopDistribution,
|
|
peerInteractions,
|
|
uptimeHeatmap,
|
|
computedStats: {
|
|
availabilityPct, longestSilenceMs, longestSilenceStart, signalGrade,
|
|
snrMean: Math.round(snrMean * 10) / 10, snrStdDev: Math.round(snrStdDev * 10) / 10,
|
|
relayPct, totalPackets, uniqueObservers, uniquePeers, avgPacketsPerDay
|
|
}
|
|
};
|
|
}
|
|
|
|
module.exports = { db, insertPacket, insertTransmission, insertPath, upsertNode, upsertObserver, updateObserverStatus, getPackets, getPacket, getTransmission, getNodes, getNode, getObservers, getStats, seed, searchNodes, getNodeHealth, getNodeAnalytics };
|