@logboard/cli 1.0.0

package/services/AnalyticsService.js

@@ -0,0 +1,665 @@
+'use strict';
+const fs = require('fs');
+const fsP = require('fs').promises;
+const path = require('path');
+const readline = require('readline');
+const {
+	getToday,
+	sanitizeAppName,
+	sanitizeDate,
+	safeLogPath,
+	formatBytes,
+} = require('../lib/utils');
+
+class AnalyticsService {
+	constructor (org) {
+		this._org = org || null;
+		this._logsDir
+      = org && org.logsDir ? org.logsDir : require('../config').LOG_BASE_DIR;
+	}
+
+	
+
+	// ─── Overview dashboard stats ─────────────────────────────────────────────
+
+	async getOverview (allowedApps = []) {
+		const today = getToday();
+		let dirs = [];
+		try {
+			dirs = await fsP.readdir(this._logsDir);
+		} catch (e) {
+			if (e.code !== 'ENOENT') {
+				throw e;
+			}
+		}
+		if (allowedApps && allowedApps.length) {
+			dirs = dirs.filter((d) => allowedApps.includes(d));
+		} else {
+			dirs = dirs.filter(
+				(d) =>
+					![
+						'app',
+						'unknown',
+						'_archive',
+						'_tmp',
+						'logboard',
+						'system',
+					].includes(d.toLowerCase()),
+			);
+		}
+		// Filter to allowed services if RBAC is active
+		if (allowedApps && allowedApps.length) {
+			dirs = dirs.filter((d) => allowedApps.includes(d));
+		} else {
+			// Always skip reserved names
+			dirs = dirs.filter(
+				(d) =>
+					![
+						'app',
+						'unknown',
+						'_archive',
+						'_tmp',
+						'logboard',
+						'system',
+					].includes(d.toLowerCase()),
+			);
+		}
+
+		let totalToday = 0,
+			totalErrors = 0,
+			totalBytes = 0;
+		const services = [];
+
+		for (const app of dirs) {
+			const appPath = path.join(this._logsDir, app);
+			try {
+				const stat = await fsP.stat(appPath);
+				if (!stat.isDirectory()) {
+					continue;
+				}
+				const files = await fsP.readdir(appPath);
+				let appBytes = 0;
+				for (const f of files.filter((f) => f.endsWith('.log'))) {
+					try {
+						appBytes += (await fsP.stat(path.join(appPath, f))).size;
+					} catch {}
+				}
+				totalBytes += appBytes;
+
+				// Count today's logs
+				const todayFile = path.join(appPath, `${today}.log`);
+				const counts = await this._countLevels(todayFile);
+				totalToday += counts.total;
+				totalErrors += counts.error || 0;
+				services.push({
+					appName: app,
+					today: counts.total,
+					error: counts.error || 0,
+					bytes: appBytes,
+				});
+			} catch {}
+		}
+
+		return {
+			services: services.length,
+			logsToday: totalToday,
+			errorsToday: totalErrors,
+			errorRate: totalToday
+				? ((totalErrors / totalToday) * 100).toFixed(1)
+				: '0.0',
+			totalStorage: formatBytes(totalBytes),
+			totalStorageBytes: totalBytes,
+			serviceList: services.sort((a, b) => b.today - a.today),
+		};
+	}
+
+	// ─── Hourly volume for a given date ───────────────────────────────────────
+
+	async getHourlyVolume (service, date, allowedApps = []) {
+		date = date || getToday();
+		try {
+			sanitizeDate(date);
+		} catch {
+			return this._emptyHours(date);
+		}
+
+		const hours = Array.from({ length: 24 }, (_, i) => ({
+			hour: i,
+			total: 0,
+			error: 0,
+			warn: 0,
+			info: 0,
+			debug: 0,
+		}));
+
+		const processFile = async (filePath) => {
+			if (!fs.existsSync(filePath)) {
+				return;
+			}
+			await new Promise((resolve) => {
+				const stream = fs.createReadStream(filePath, 'utf8');
+				const rl = readline.createInterface({
+					input: stream,
+					crlfDelay: Infinity,
+				});
+				rl.on('line', (line) => {
+					if (!line.trim()) {
+						return;
+					}
+					try {
+						const p = JSON.parse(line);
+						const h = new Date(p.ts).getUTCHours();
+						const lvl = (p.level || 'info').toLowerCase();
+						hours[h].total++;
+						if (hours[h][lvl] !== undefined) {
+							hours[h][lvl]++;
+						}
+					} catch {}
+				});
+				rl.on('close', resolve);
+				rl.on('error', resolve);
+				stream.on('error', resolve);
+			});
+		};
+
+		if (service) {
+			try {
+				sanitizeAppName(service);
+			} catch {
+				return this._emptyHours(date);
+			}
+			await processFile(safeLogPath(this._logsDir, service, date));
+		} else {
+			let dirs = [];
+			try {
+				dirs = await fsP.readdir(this._logsDir);
+			} catch {}
+			for (const app of dirs) {
+				const fp = path.join(this._logsDir, app, `${date}.log`);
+				await processFile(fp);
+			}
+
+			// RBAC: filter to allowed services; always skip reserved names
+			if (allowedApps && allowedApps.length) {
+				dirs = dirs.filter((d) => allowedApps.includes(d));
+			} else {
+				dirs = dirs.filter(
+					(d) =>
+						![
+							'app',
+							'unknown',
+							'_archive',
+							'_tmp',
+							'logboard',
+							'system',
+						].includes(d.toLowerCase()),
+				);
+			}
+		}
+		return { date, service: service || 'all', hours };
+	}
+
+	// ─── Level breakdown ──────────────────────────────────────────────────────
+
+	async getLevelBreakdown (service, date) {
+		date = date || getToday();
+		let filePaths = [];
+		try {
+			if (service) {
+				sanitizeAppName(service);
+				sanitizeDate(date);
+				filePaths = [safeLogPath(this._logsDir, service, date)];
+			} else {
+				sanitizeDate(date);
+				let dirs = [];
+				try {
+					dirs = await fsP.readdir(this._logsDir);
+				} catch {}
+				for (const app of dirs) {
+					filePaths.push(path.join(this._logsDir, app, `${date}.log`));
+				}
+
+				// RBAC: filter to allowed services; always skip reserved names
+				if (allowedApps && allowedApps.length) {
+					dirs = dirs.filter((d) => allowedApps.includes(d));
+				} else {
+					dirs = dirs.filter(
+						(d) =>
+							![
+								'app',
+								'unknown',
+								'_archive',
+								'_tmp',
+								'logboard',
+								'system',
+							].includes(d.toLowerCase()),
+					);
+				}
+			}
+		} catch {
+			return { error: 0, warn: 0, info: 0, debug: 0, total: 0 };
+		}
+
+		const counts = { error: 0, warn: 0, info: 0, debug: 0, total: 0 };
+		for (const fp of filePaths) {
+			const c = await this._countLevels(fp);
+			counts.error += c.error || 0;
+			counts.warn += c.warn || 0;
+			counts.info += c.info || 0;
+			counts.debug += c.debug || 0;
+			counts.total += c.total || 0;
+		}
+		return counts;
+	}
+
+	// ─── Top services by volume ───────────────────────────────────────────────
+
+	async getTopServices (date, topN = 10, allowedApps = []) {
+		date = date || getToday();
+		let dirs = [];
+		try {
+			dirs = await fsP.readdir(this._logsDir);
+		} catch {}
+		if (allowedApps && allowedApps.length) {
+			dirs = dirs.filter((d) => allowedApps.includes(d));
+		} else {
+			dirs = dirs.filter(
+				(d) =>
+					![
+						'app',
+						'unknown',
+						'_archive',
+						'_tmp',
+						'logboard',
+						'system',
+					].includes(d.toLowerCase()),
+			);
+		}
+		const results = [];
+		for (const app of dirs) {
+			const fp = path.join(this._logsDir, app, `${date}.log`);
+			const c = await this._countLevels(fp);
+			if (c.total > 0) {
+				results.push({ appName: app, ...c });
+			}
+		}
+
+		// RBAC: filter to allowed services; always skip reserved names
+		if (allowedApps && allowedApps.length) {
+			dirs = dirs.filter((d) => allowedApps.includes(d));
+		} else {
+			dirs = dirs.filter(
+				(d) =>
+					![
+						'app',
+						'unknown',
+						'_archive',
+						'_tmp',
+						'logboard',
+						'system',
+					].includes(d.toLowerCase()),
+			);
+		}
+		return results.sort((a, b) => b.total - a.total).slice(0, topN);
+	}
+
+	// ─── Recent errors ────────────────────────────────────────────────────────
+
+	async getRecentErrors (limit = 20, allowedApps = []) {
+		const today = getToday();
+		const errors = [];
+		let dirs = [];
+		try {
+			dirs = await fsP.readdir(this._logsDir);
+		} catch {}
+
+		// RBAC: filter to allowed services; always skip reserved names
+		if (allowedApps && allowedApps.length) {
+			dirs = dirs.filter((d) => allowedApps.includes(d));
+		} else {
+			dirs = dirs.filter(
+				(d) =>
+					![
+						'app',
+						'unknown',
+						'_archive',
+						'_tmp',
+						'logboard',
+						'system',
+					].includes(d.toLowerCase()),
+			);
+		}
+		for (const app of dirs) {
+			const fp = path.join(this._logsDir, app, `${today}.log`);
+			if (!fs.existsSync(fp)) {
+				continue;
+			}
+			await new Promise((resolve) => {
+				const stream = fs.createReadStream(fp, 'utf8');
+				const rl = readline.createInterface({
+					input: stream,
+					crlfDelay: Infinity,
+				});
+				rl.on('line', (line) => {
+					if (!line.trim()) {
+						return;
+					}
+					try {
+						const p = JSON.parse(line);
+						if ((p.level || '').toLowerCase() === 'error') {
+							errors.push({ ...p, _appName: app });
+						}
+					} catch {}
+				});
+				rl.on('close', resolve);
+				rl.on('error', resolve);
+				stream.on('error', resolve);
+			});
+		}
+		return errors
+			.sort((a, b) => new Date(b.ts) - new Date(a.ts))
+			.slice(0, limit);
+	}
+
+	// ─── Multi-day trend (last N days) ───────────────────────────────────────
+
+	async getDailyTrend (service, days = 7, allowedApps = []) {
+		const trend = [];
+		for (let i = days - 1; i >= 0; i--) {
+			const d = new Date();
+			d.setDate(d.getDate() - i);
+			const date = d.toISOString().slice(0, 10);
+			const breakdown = await this.getLevelBreakdown(service, date);
+			trend.push({ date, ...breakdown });
+		}
+		return trend;
+	}
+
+	// ─── Private helpers ──────────────────────────────────────────────────────
+
+	async _countLevels (filePath) {
+		const counts = { error: 0, warn: 0, info: 0, debug: 0, total: 0 };
+		if (!fs.existsSync(filePath)) {
+			return counts;
+		}
+		return new Promise((resolve) => {
+			const stream = fs.createReadStream(filePath, 'utf8');
+			const rl = readline.createInterface({
+				input: stream,
+				crlfDelay: Infinity,
+			});
+			rl.on('line', (line) => {
+				if (!line.trim()) {
+					return;
+				}
+				counts.total++;
+				try {
+					const lvl = (JSON.parse(line).level || 'info').toLowerCase();
+					if (counts[lvl] !== undefined) {
+						counts[lvl]++;
+					}
+				} catch {
+					counts.info++;
+				}
+			});
+			rl.on('close', () => resolve(counts));
+			rl.on('error', () => resolve(counts));
+			stream.on('error', () => resolve(counts));
+		});
+	}
+
+	_emptyHours (date) {
+		return {
+			date,
+			service: 'all',
+			hours: Array.from({ length: 24 }, (_, i) => ({
+				hour: i,
+				total: 0,
+				error: 0,
+				warn: 0,
+				info: 0,
+				debug: 0,
+			})),
+		};
+	}
+
+	// ─── Status page ─────────────────────────────────────────────────────────
+	async getStatusPage () {
+		const today = getToday();
+		const dirs = [];
+		try {
+			(await fsP.readdir(this._logsDir)).forEach((d) => dirs.push(d));
+		} catch {}
+
+		const services = [];
+		for (const app of dirs) {
+			if (app.startsWith('_')) {
+				continue;
+			} // skip _archive
+			const appPath = path.join(this._logsDir, app);
+			try {
+				const stat = await fsP.stat(appPath);
+				if (!stat.isDirectory()) {
+					continue;
+				}
+			} catch {
+				continue;
+			}
+
+			// Build 90-day history
+			const history = [];
+			const now = new Date();
+			let uptimeDays = 0,
+				totalDays = 0;
+			for (let i = 89; i >= 0; i--) {
+				const d = new Date(now);
+				d.setDate(d.getDate() - i);
+				const dateStr = d.toISOString().slice(0, 10);
+				const fp = safeLogPath(this._logsDir, app, dateStr);
+				try {
+					if (!require('fs').existsSync(fp)) {
+						history.push({ date: dateStr, status: 'no-data' });
+						continue;
+					}
+					const counts = await this._countLevels(fp);
+					const rate = counts.total
+						? ((counts.error || 0) / counts.total) * 100
+						: 0;
+					const status
+            = rate > 10 ? 'degraded' : rate > 3 ? 'warning' : 'operational';
+					history.push({
+						date: dateStr,
+						status,
+						total: counts.total,
+						errors: counts.error || 0,
+					});
+					totalDays++;
+					if (status === 'operational') {
+						uptimeDays++;
+					}
+				} catch {
+					history.push({ date: dateStr, status: 'no-data' });
+				}
+			}
+			const uptime = totalDays
+				? ((uptimeDays / totalDays) * 100).toFixed(1)
+				: '0.0';
+			const last = history[history.length - 1];
+			services.push({
+				appName: app,
+				uptime,
+				status: last?.status || 'no-data',
+				history,
+			});
+		}
+
+		const overall = services.every((s) => s.status === 'operational')
+			? 'operational'
+			: services.some((s) => s.status === 'degraded')
+				? 'degraded'
+				: services.some((s) => s.status === 'warning')
+					? 'warning'
+					: 'operational';
+
+		return { overall, services, generatedAt: new Date().toISOString() };
+	}
+
+	async getHeatmap (appName) {
+		const { sanitizeAppName, safeLogPath } = require('../lib/utils');
+		appName = sanitizeAppName(appName);
+		const days = [];
+		const today = new Date();
+		let totalErrors = 0,
+			daysWithErrors = 0,
+			worstDay = null;
+		for (let i = 89; i >= 0; i--) {
+			const d = new Date(today);
+			d.setDate(d.getDate() - i);
+			const dateStr = d.toISOString().slice(0, 10);
+			const fp = safeLogPath(this._logsDir, appName, dateStr);
+			try {
+				if (!require('fs').existsSync(fp)) {
+					days.push({ date: dateStr, errors: 0, total: 0 });
+					continue;
+				}
+				const c = await this._countLevels(fp);
+				days.push({ date: dateStr, errors: c.error || 0, total: c.total || 0 });
+				totalErrors += c.error || 0;
+				if (c.error > 0) {
+					daysWithErrors++;
+					if (!worstDay || c.error > worstDay.errors) {
+						worstDay = { date: dateStr, errors: c.error };
+					}
+				}
+			} catch {
+				days.push({ date: dateStr, errors: 0, total: 0 });
+			}
+		}
+		const avgErrorsPerDay = daysWithErrors ? totalErrors / daysWithErrors : 0;
+		return { days, totalErrors, daysWithErrors, worstDay, avgErrorsPerDay };
+	}
+
+	// ── Per-service health for health page ──────────────────────────────────────
+	async getServiceHealth (allowedApps = []) {
+		const today = getToday();
+		const services = [];
+		let dirs = [];
+		try {
+			dirs = await fsP.readdir(this._logsDir);
+		} catch {}
+		if (allowedApps && allowedApps.length) {
+			dirs = dirs.filter((d) => allowedApps.includes(d));
+		} else {
+			dirs = dirs.filter(
+				(d) =>
+					![
+						'app',
+						'unknown',
+						'_archive',
+						'_tmp',
+						'logboard',
+						'system',
+					].includes(d.toLowerCase()),
+			);
+		}
+
+		for (const appName of dirs) {
+			if (appName.startsWith('_') || appName.endsWith('-requests')) {
+				continue;
+			}
+			const appDir = path.join(this._logsDir, appName);
+			try {
+				if (!(await fsP.stat(appDir)).isDirectory()) {
+					continue;
+				}
+			} catch {
+				continue;
+			}
+
+			// RBAC: filter to allowed services; always skip reserved names
+			if (allowedApps && allowedApps.length) {
+				dirs = dirs.filter((d) => allowedApps.includes(d));
+			} else {
+				dirs = dirs.filter(
+					(d) =>
+						![
+							'app',
+							'unknown',
+							'_archive',
+							'_tmp',
+							'logboard',
+							'system',
+						].includes(d.toLowerCase()),
+				);
+			}
+			const fp = safeLogPath(this._logsDir, appName, today);
+			let logsToday = 0,
+				errors = 0,
+				warns = 0,
+				lastSeen = null,
+				recentErrors = [];
+
+			try {
+				if (fs.existsSync(fp)) {
+					await new Promise((resolve) => {
+						const rl = readline.createInterface({
+							input: fs.createReadStream(fp, 'utf8'),
+							crlfDelay: Infinity,
+						});
+						rl.on('line', (line) => {
+							if (!line.trim()) {
+								return;
+							}
+							logsToday++;
+							try {
+								const p = JSON.parse(line);
+								const lvl = (p.level || '').toLowerCase();
+								if (lvl === 'error' || lvl === 'fatal') {
+									errors++;
+									if (recentErrors.length < 3) {
+										recentErrors.push(p.message || line.slice(0, 80));
+									}
+								}
+								if (lvl === 'warn') {
+									warns++;
+								}
+								if (p.ts) {
+									lastSeen = p.ts;
+								}
+							} catch {}
+						});
+						rl.on('close', resolve);
+						rl.on('error', resolve);
+					});
+				}
+			} catch {}
+
+			const errorRate = logsToday ? Math.round((errors / logsToday) * 100) : 0;
+			const status
+        = errorRate > 10 ? 'critical' : errorRate > 3 ? 'warn' : 'ok';
+			const lastSeenStr = lastSeen
+				? new Date(lastSeen).toLocaleTimeString([], {
+					hour: '2-digit',
+					minute: '2-digit',
+				})
+				: null;
+
+			services.push({
+				appName,
+				logsToday,
+				errors,
+				warns,
+				errorRate,
+				status,
+				lastSeen: lastSeenStr,
+				recentErrors,
+			});
+		}
+
+		return services.sort((a, b) => b.errors - a.errors);
+	}
+}
+
+module.exports = AnalyticsService;
+
+// ── Per-service health for health page ───────────────────────────────────