@logboard/cli 1.0.0

package/client/logger.js

@@ -0,0 +1,309 @@
+'use strict';
+/**
+ * LogBoard Client Logger
+ * Drop-in structured logger that ships to LogBoard.
+ *
+ * Usage:
+ *   const logger = require('./client/logger');
+ *   logger.configure({ appName:'my-api', remoteUrl:'http://logboard:9900/api/logs', apiKey:'blq_...' });
+ *   app.use(logger.requestLogger());          // request metrics
+ *   const log = logger.create({ service:'PaymentSvc' });
+ *   log.info('done', { amount:99 });
+ */
+const os = require('os');
+const crypto = require('crypto');
+
+const CFG = {
+	appName: process.env.APP_NAME || 'app',
+	remoteUrl: process.env.LOG_REMOTE_URL || 'http://localhost:9900/api/logs',
+	apiKey: process.env.LOG_API_KEY || '',
+	level: process.env.LOG_LEVEL || 'info',
+	prettyPrint: process.env.NODE_ENV !== 'production',
+	bufferSize: Number(process.env.LOG_BUFFER_SIZE) || 50,
+	flushInterval: Number(process.env.LOG_FLUSH_INTERVAL) || 100,
+	remoteTimeout: Number(process.env.LOG_REMOTE_TIMEOUT) || 200,
+	remoteRetries: Number(process.env.LOG_REMOTE_RETRIES) || 2,
+	interceptConsole: process.env.LOG_INTERCEPT === 'true',
+	skipPaths: (process.env.LOG_SKIP_PATHS || '/health,/ping,/favicon')
+		.split(',')
+		.map((s) => s.trim()),
+};
+
+const LEVELS = { debug: 10, info: 20, warn: 30, error: 40, fatal: 50 };
+const MASK = [
+	'authorization',
+	'token',
+	'password',
+	'secret',
+	'apikey',
+	'key',
+	'auth',
+];
+const state = { buf: [], fp: null, installed: false, orig: null };
+
+function shouldLog (l) {
+	return (LEVELS[l] || 0) >= (LEVELS[CFG.level] || 20);
+}
+
+function safeStr (o) {
+	const s = new WeakSet();
+	return JSON.stringify(o, (k, v) => {
+		if (typeof v === 'object' && v !== null) {
+			if (s.has(v)) {
+				return '[Circular]';
+			}
+			s.add(v);
+		}
+		if (k && MASK.some((m) => k.toLowerCase().includes(m))) {
+			return '***';
+		}
+		return v;
+	});
+}
+
+function fmt (level, appName, ctx, msg, extras) {
+	const p = {
+		ts: new Date().toISOString(),
+		level: level.toUpperCase(),
+		appName: appName || CFG.appName,
+		host: os.hostname(),
+		pid: process.pid,
+		...ctx,
+		message: String(msg),
+	};
+	if (extras && extras.length) {
+		p.data = extras.map((x) =>
+			x instanceof Error ? { errorMessage: x.message, stack: x.stack } : x,
+		);
+	}
+	return CFG.prettyPrint ? JSON.stringify(p, null, 2) : safeStr(p);
+}
+
+function enq (line) {
+	state.buf.push(line);
+	if (state.buf.length >= CFG.bufferSize) {
+		flush();
+	}
+}
+
+function flush () {
+	if (state.fp) {
+		state.fp = state.fp.then(() => drain());
+		return;
+	}
+	state.fp = drain().finally(() => {
+		state.fp = null;
+	});
+}
+
+async function drain () {
+	return new Promise((r) =>
+		setImmediate(async () => {
+			const logs = state.buf.splice(0);
+			if (!logs.length) {
+				r();
+				return;
+			}
+			if (CFG.prettyPrint) {
+				for (const l of logs) {
+					try {
+						process.stdout.write(`${l}\n`);
+					} catch {}
+				}
+			}
+			if (CFG.remoteUrl) {
+				send(logs).catch(() => {});
+			}
+			r();
+		}),
+	);
+}
+
+async function send (logs) {
+	let a = 0,
+		max = CFG.remoteRetries + 1;
+	while (a < max) {
+		try {
+			const r = await fetch(CFG.remoteUrl, {
+				method: 'POST',
+				headers: {
+					'Content-Type': 'application/json',
+					...(CFG.apiKey ? { 'x-api-key': CFG.apiKey } : {}),
+				},
+				body: JSON.stringify({ appName: CFG.appName, logs }),
+				signal: AbortSignal.timeout(CFG.remoteTimeout),
+			});
+			if (r.ok) {
+				return;
+			}
+			throw new Error(`HTTP ${r.status}`);
+		} catch {
+			a++;
+			if (a >= max) {
+				return;
+			}
+			await new Promise((r) => setTimeout(r, 200 * Math.pow(2, a - 1)));
+		}
+	}
+}
+
+class Logger {
+	constructor (ctx = {}) {
+		this.ctx = ctx;
+		this.appName = ctx.appName || CFG.appName;
+	}
+
+	child (e = {}) {
+		return new Logger({ ...this.ctx, ...e });
+	}
+
+	_l (l, m, p) {
+		if (!shouldLog(l)) {
+			return;
+		}
+		enq(fmt(l, this.appName, this.ctx, m, p));
+	}
+
+	debug (m, ...p) {
+		this._l('debug', m, p);
+	}
+
+	info (m, ...p) {
+		this._l('info', m, p);
+	}
+
+	warn (m, ...p) {
+		this._l('warn', m, p);
+	}
+
+	error (m, ...p) {
+		this._l('error', m, p);
+	}
+
+	fatal (m, ...p) {
+		if (!shouldLog('fatal')) {
+			return;
+		}
+		const f = fmt('fatal', this.appName, this.ctx, m, p);
+		try {
+			process.stderr.write(`${f}\n`);
+		} catch {}
+		if (CFG.remoteUrl) {
+			send([f]).catch(() => {});
+		}
+	}
+}
+
+const root = new Logger();
+
+root.configure = function (opts = {}) {
+	Object.assign(CFG, opts);
+	if (opts.interceptConsole) {
+		root.install();
+	}
+};
+root.create = function (ctx = {}) {
+	return new Logger(ctx);
+};
+
+root.install = function () {
+	if (state.installed) {
+		return;
+	}
+	state.installed = true;
+	state.orig = {
+		log: console.log.bind(console),
+		warn: console.warn.bind(console),
+		error: console.error.bind(console),
+		debug: console.debug.bind(console),
+		info: console.info.bind(console),
+	};
+	const mk = (l, o) =>
+		function (...a) {
+			o(...a);
+			const m = a
+				.map((x) => (typeof x === 'string' ? x : safeStr(x)))
+				.join(' ');
+			if (shouldLog(l)) {
+				enq(fmt(l, CFG.appName, {}, m, []));
+			}
+		};
+	console.log = mk('info', state.orig.log);
+	console.info = mk('info', state.orig.info);
+	console.warn = mk('warn', state.orig.warn);
+	console.error = mk('error', state.orig.error);
+	console.debug = mk('debug', state.orig.debug);
+};
+root.uninstall = function () {
+	if (!state.installed || !state.orig) {
+		return;
+	}
+	Object.assign(console, state.orig);
+	state.installed = false;
+};
+root.console = {
+	log: (...a) => root.info(...a),
+	info: (...a) => root.info(...a),
+	warn: (...a) => root.warn(...a),
+	error: (...a) => root.error(...a),
+	debug: (...a) => root.debug(...a),
+};
+
+root.requestLogger = function () {
+	return function (req, res, next) {
+		const raw = req.path || req.url?.split('?')[0] || '/';
+		if (CFG.skipPaths.some((p) => raw.startsWith(p))) {
+			return next();
+		}
+		const t = process.hrtime.bigint(),
+			rid = req.headers['x-request-id'] || crypto.randomUUID(),
+			rsz = parseInt(req.headers['content-length'] || '0', 10) || 0;
+		req.requestId = rid;
+		res.setHeader('X-Request-Id', rid);
+		let done = false;
+		const rec = () => {
+			if (done) {
+				return;
+			}
+			done = true;
+			const ms = Math.round(Number(process.hrtime.bigint() - t) / 1e4) / 100,
+				sc = res.statusCode,
+				p = (req.baseUrl || '') + (req.route ? req.route.path : raw);
+			enq(
+				JSON.stringify({
+					ts: new Date().toISOString(),
+					level: sc >= 500 ? 'error' : sc >= 400 ? 'warn' : 'info',
+					appName: `${CFG.appName}-requests`,
+					type: 'api_request',
+					requestId: rid,
+					method: req.method,
+					path: p,
+					statusCode: sc,
+					durationMs: ms,
+					reqSizeBytes: rsz,
+					resSizeBytes:
+            parseInt(res.getHeader('content-length') || '0', 10) || 0,
+					message: `${req.method} ${p} ${sc} ${ms}ms`,
+				}),
+			);
+		};
+		res.once('finish', rec);
+		res.once('close', rec);
+		next();
+	};
+};
+
+setInterval(() => flush(), CFG.flushInterval).unref();
+process.on('beforeExit', () => flush());
+process.on('SIGINT', () => {
+	flush();
+	process.exit(0);
+});
+process.on('SIGTERM', () => {
+	flush();
+	process.exit(0);
+});
+if (CFG.interceptConsole) {
+	root.install();
+}
+module.exports = root;

package/config/index.js

@@ -0,0 +1,142 @@
+'use strict';
+const path = require('path');
+const ROOT = path.join(__dirname, '..');
+try {
+	require('dotenv').config({ path: path.join(ROOT, '.env') });
+} catch (_) {}
+
+function str (n, f) {
+	return process.env[n] || f;
+}
+
+function int (n, f) {
+	const v = process.env[n];
+	if (!v) {
+		return f;
+	}
+	const i = parseInt(v, 10);
+	if (isNaN(i)) {
+		throw new Error(`[Config] ${n} must be integer`);
+	}
+	return i;
+}
+
+function bool (n, f) {
+	const v = process.env[n];
+	if (!v) {
+		return f;
+	}
+	return v === 'true' || v === '1';
+}
+
+const JWT_SECRET = str('JWT_SECRET', '');
+const NODE_ENV = str('NODE_ENV', 'development');
+
+if (NODE_ENV === 'production') {
+	if (!JWT_SECRET || JWT_SECRET.length < 32) {
+		throw new Error('[Config] JWT_SECRET must be ≥32 chars in production');
+	}
+}
+
+const DATA_DIR = path.resolve(str('DATA_DIR', path.join(ROOT, 'data')));
+const LOG_BASE_DIR = path.resolve(str('LOG_BASE_DIR', path.join(ROOT, 'logs')));
+
+const cfg = {
+	NODE_ENV,
+	PORT: int('PORT', 9900),
+	LOG_BASE_DIR,
+	DATA_DIR,
+	RETENTION_DAYS: int('RETENTION_DAYS', 7),
+	CLEANUP_INTERVAL: int('CLEANUP_INTERVAL', 86400000),
+	BATCH_SIZE: int('BATCH_SIZE', 20),
+	BATCH_TIMEOUT: int('BATCH_TIMEOUT', 200),
+	JWT_SECRET: JWT_SECRET || 'dev-secret-change-in-production',
+	JWT_EXPIRES_IN: str('JWT_EXPIRES_IN', '24h'),
+	SESSION_NAME: str('SESSION_NAME', 'logboard_session'),
+	MAX_BODY_SIZE: str('MAX_BODY_SIZE', '10mb'),
+	ENABLE_STREAM: bool('ENABLE_STREAM', true),
+	CORS_ORIGINS: str('CORS_ORIGINS', 'http://localhost:9900')
+		.split(',')
+		.map((s) => s.trim()),
+	WEBHOOK_URL: str('WEBHOOK_URL', ''),
+	TENANT_MODE: bool('TENANT_MODE', true), // multi-tenancy enabled by default now
+
+	// ── Legacy flat paths (used for super-admin + backward compat) ────────────
+	USERS_FILE: path.join(DATA_DIR, 'users.json'),
+	SETTINGS_FILE: path.join(DATA_DIR, 'settings.json'),
+	ROLES_FILE: path.join(DATA_DIR, 'role-config.json'),
+	API_KEYS_FILE: path.join(DATA_DIR, 'api-keys.json'),
+	AUDIT_FILE: path.join(DATA_DIR, 'audit.ndjson'),
+	ALERTS_FILE: path.join(DATA_DIR, 'alerts.json'),
+	ARCHIVE_DIR: path.join(LOG_BASE_DIR, '_archive'),
+	TENANTS_FILE: path.join(DATA_DIR, 'tenants.json'),
+	BOOKMARKS_FILE: path.join(DATA_DIR, 'bookmarks.json'),
+	SAVED_SEARCHES_FILE: path.join(DATA_DIR, 'saved-searches.json'),
+	NOTIFICATIONS_FILE: path.join(DATA_DIR, 'notifications.json'),
+	TEAMS_FILE: path.join(DATA_DIR, 'teams.json'),
+	DASHBOARDS_FILE: path.join(DATA_DIR, 'dashboards.json'),
+
+	// ── Org-aware path helpers ────────────────────────────────────────────────
+	// Returns the data dir for an org (or global if no org)
+	orgDataDir (orgSlug) {
+		return orgSlug ? path.join(DATA_DIR, 'orgs', orgSlug) : DATA_DIR;
+	},
+	orgLogsDir (orgSlug) {
+		return orgSlug ? path.join(LOG_BASE_DIR, orgSlug) : LOG_BASE_DIR;
+	},
+	orgUsersFile (s) {
+		return path.join(cfg.orgDataDir(s), 'users.json');
+	},
+	orgSettingsFile (s) {
+		return path.join(cfg.orgDataDir(s), 'settings.json');
+	},
+	orgRolesFile (s) {
+		return path.join(cfg.orgDataDir(s), 'role-config.json');
+	},
+	orgApiKeysFile (s) {
+		return path.join(cfg.orgDataDir(s), 'api-keys.json');
+	},
+	orgAuditFile (s) {
+		return path.join(cfg.orgDataDir(s), 'audit.ndjson');
+	},
+	orgAlertsFile (s) {
+		return path.join(cfg.orgDataDir(s), 'alerts.json');
+	},
+	orgBookmarksFile (s) {
+		return path.join(cfg.orgDataDir(s), 'bookmarks.json');
+	},
+	orgSavedSearchesFile (s) {
+		return path.join(cfg.orgDataDir(s), 'saved-searches.json');
+	},
+	orgNotificationsFile (s) {
+		return path.join(cfg.orgDataDir(s), 'notifications.json');
+	},
+
+	// Branding
+	APP_NAME: str('APP_NAME', 'LogBoard'),
+	APP_LOGO_URL: str('APP_LOGO_URL', '/public/logo.png'),
+
+	// Health thresholds
+	ALERT_RAM_PCT: int('ALERT_RAM_PCT', 85),
+	ALERT_CPU_PCT: int('ALERT_CPU_PCT', 90),
+	ALERT_DISK_PCT: int('ALERT_DISK_PCT', 90),
+
+	// OAuth
+	GITHUB_CLIENT_ID: str('GITHUB_CLIENT_ID', ''),
+	GITHUB_CLIENT_SECRET: str('GITHUB_CLIENT_SECRET', ''),
+	GOOGLE_CLIENT_ID: str('GOOGLE_CLIENT_ID', ''),
+	GOOGLE_CLIENT_SECRET: str('GOOGLE_CLIENT_SECRET', ''),
+	OAUTH_CALLBACK_BASE: str('OAUTH_CALLBACK_BASE', 'http://localhost:9900'),
+
+	// Email
+	SMTP_HOST: str('SMTP_HOST', ''),
+	SMTP_PORT: int('SMTP_PORT', 587),
+	SMTP_USER: str('SMTP_USER', ''),
+	SMTP_PASS: str('SMTP_PASS', ''),
+	SMTP_FROM: str('SMTP_FROM', 'logboard@example.com'),
+	SENDGRID_KEY: str('SENDGRID_API_KEY', ''),
+	PAGERDUTY_KEY: str('PAGERDUTY_ROUTING_KEY', ''),
+	API_KEY: str('API_KEY', 'change-me-secret-key'),
+};
+
+module.exports = cfg;

package/config.js

@@ -0,0 +1,2 @@
+// Backward-compat shim — all config now lives in config/index.js
+module.exports = require('./config/index');

package/controllers/AnalyticsController.js

@@ -0,0 +1,46 @@
+'use strict';
+
+class AnalyticsController {
+	constructor (analyticsService) { this.svc = analyticsService; }
+
+	async overview (req, res) {
+		try { res.json(await this.svc.getOverview()); } catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async hourly (req, res) {
+		try {
+			const { service, date } = req.query;
+			res.json(await this.svc.getHourlyVolume(service, date));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async levels (req, res) {
+		try {
+			const { service, date } = req.query;
+			res.json(await this.svc.getLevelBreakdown(service, date));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async topServices (req, res) {
+		try {
+			const { date, top } = req.query;
+			res.json(await this.svc.getTopServices(date, parseInt(top, 10) || 10));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async recentErrors (req, res) {
+		try {
+			const limit = Math.min(parseInt(req.query.limit, 10) || 20, 100);
+			res.json(await this.svc.getRecentErrors(limit));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async trend (req, res) {
+		try {
+			const { service, days } = req.query;
+			res.json(await this.svc.getDailyTrend(service, parseInt(days, 10) || 7));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+}
+
+module.exports = AnalyticsController;

package/controllers/ApiAnalyticsController.js

@@ -0,0 +1,129 @@
+'use strict';
+
+class ApiAnalyticsController {
+	constructor (apiAnalyticsService) { this.svc = apiAnalyticsService; }
+
+	async services (req, res) {
+		try { res.json(await this.svc.getApiServices()); } catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async overview (req, res) {
+		try {
+			const { service, date } = req.query;
+			if (!service) { return res.status(400).json({ error: 'service required' }); }
+			res.json(await this.svc.getOverview(service, date));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async hourly (req, res) {
+		try {
+			const { service, date } = req.query;
+			if (!service) { return res.status(400).json({ error: 'service required' }); }
+			res.json(await this.svc.getHourlyVolume(service, date));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async endpoints (req, res) {
+		try {
+			const { service, date } = req.query;
+			if (!service) { return res.status(400).json({ error: 'service required' }); }
+			res.json(await this.svc.getEndpointStats(service, date));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async slowest (req, res) {
+		try {
+			const { service, date } = req.query;
+			const topN = Math.min(parseInt(req.query.top, 10) || 10, 50);
+			if (!service) { return res.status(400).json({ error: 'service required' }); }
+			res.json(await this.svc.getTopSlowest(service, date, topN));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async topErrors (req, res) {
+		try {
+			const { service, date } = req.query;
+			const topN = Math.min(parseInt(req.query.top, 10) || 10, 50);
+			if (!service) { return res.status(400).json({ error: 'service required' }); }
+			res.json(await this.svc.getTopErrors(service, date, topN));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async statusDist (req, res) {
+		try {
+			const { service, date } = req.query;
+			if (!service) { return res.status(400).json({ error: 'service required' }); }
+			res.json(await this.svc.getStatusDistribution(service, date));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async apdex (req, res) {
+		try {
+			const { service, date } = req.query;
+			const tMs = parseInt(req.query.t, 10) || 200;
+			if (!service) { return res.status(400).json({ error: 'service required' }); }
+			res.json(await this.svc.getApdex(service, date, tMs));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async trend (req, res) {
+		try {
+			const { service } = req.query;
+			const days = Math.min(parseInt(req.query.days, 10) || 7, 30);
+			if (!service) { return res.status(400).json({ error: 'service required' }); }
+			res.json(await this.svc.getDailyTrend(service, days));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async heaviest (req, res) {
+		try {
+			const { service, date } = req.query;
+			const topN = Math.min(parseInt(req.query.top, 10) || 10, 50);
+			if (!service) { return res.status(400).json({ error: 'service required' }); }
+			res.json(await this.svc.getTopHeaviest(service, date, topN));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async individualSlowest (req, res) {
+		try {
+			const { service, date } = req.query;
+			const topN = Math.min(parseInt(req.query.top, 10) || 20, 100);
+			if (!service) { return res.status(400).json({ error: 'service required' }); }
+			res.json(await this.svc.getIndividualSlowest(service, date, topN));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async peakRpm (req, res) {
+		try {
+			const { service, date } = req.query;
+			if (!service) { return res.status(400).json({ error: 'service required' }); }
+			res.json(await this.svc.getPeakRpm(service, date));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async slowTrend (req, res) {
+		try {
+			const { service, start, end } = req.query;
+			if (!service || !start || !end) { return res.status(400).json({ error: 'service, start, end required' }); }
+			res.json(await this.svc.getSlowTrend(service, start, end));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async errorTrend (req, res) {
+		try {
+			const { service, start, end } = req.query;
+			if (!service || !start || !end) { return res.status(400).json({ error: 'service, start, end required' }); }
+			res.json(await this.svc.getErrorTrend(service, start, end));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+
+	async hourlyPattern (req, res) {
+		try {
+			const { service, start, end } = req.query;
+			if (!service || !start || !end) { return res.status(400).json({ error: 'service, start, end required' }); }
+			res.json(await this.svc.getHourlySlowPattern(service, start, end));
+		} catch (err) { res.status(500).json({ error: err.message }); }
+	}
+}
+
+module.exports = ApiAnalyticsController;

package/controllers/ApiKeyController.js

@@ -0,0 +1,58 @@
+const audit = require('../services/AuditService');
+('use strict');
+const ApiKeyService = require('../services/ApiKeyService');
+const svc = new ApiKeyService();
+class ApiKeyController {
+	async list (req, res) {
+		try {
+			res.json(await svc.list());
+		} catch (e) {
+			res.status(500).json({ error: e.message });
+		}
+	}
+
+	async create (req, res) {
+		try {
+			const { name, scopes, expiresAt } = req.body;
+			res
+				.status(201)
+				.json(
+					await svc.create({
+						name,
+						scopes,
+						expiresAt,
+						createdBy: req.user.username,
+					}),
+				);
+		} catch (e) {
+			res.status(e.status || 500).json({ error: e.message });
+		}
+	}
+
+	async update (req, res) {
+		try {
+			res.json(await svc.update(req.params.id, req.body, req.user.username));
+		} catch (e) {
+			res.status(e.status || 500).json({ error: e.message });
+		}
+	}
+
+	async revoke (req, res) {
+		try {
+			await svc.revoke(req.params.id, req.user.username);
+			res.json({ success: true });
+		} catch (e) {
+			res.status(e.status || 500).json({ error: e.message });
+		}
+	}
+
+	async remove (req, res) {
+		try {
+			await svc.remove(req.params.id, req.user.username);
+			res.json({ success: true });
+		} catch (e) {
+			res.status(e.status || 500).json({ error: e.message });
+		}
+	}
+}
+module.exports = ApiKeyController;