blockmine 1.25.0 → 1.27.0

package/backend/src/core/logging/AuditLogger.js

@@ -0,0 +1,61 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const AUDIT_LOG_DIR = path.join(os.homedir(), '.blockmine', 'logs');
+const AUDIT_LOG_FILE = path.join(AUDIT_LOG_DIR, 'audit.log');
+
+class AuditLogger {
+    constructor({ logFile = AUDIT_LOG_FILE } = {}) {
+        this.logFile = logFile;
+        this._ensureDir();
+    }
+
+    _ensureDir() {
+        const dir = path.dirname(this.logFile);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+
+    log(event) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            ...event,
+        };
+
+        const line = JSON.stringify(entry);
+        const hash = crypto.createHash('sha256').update(line).digest('hex');
+        const record = JSON.stringify({ ...entry, _hash: hash }) + '\n';
+
+        try {
+            fs.appendFileSync(this.logFile, record, 'utf8');
+        } catch {}
+    }
+
+    authFailure({ userId, username, ip, reason }) {
+        this.log({ type: 'auth.failure', userId, username, ip, reason });
+    }
+
+    authSuccess({ userId, username, ip }) {
+        this.log({ type: 'auth.success', userId, username, ip });
+    }
+
+    authorizationFailure({ userId, username, resource, action, ip }) {
+        this.log({ type: 'authorization.failure', userId, username, resource, action, ip });
+    }
+
+    sensitiveAction({ userId, username, action, resource, ip }) {
+        this.log({ type: 'sensitive.action', userId, username, action, resource, ip });
+    }
+}
+
+let instance = null;
+
+function getAuditLogger() {
+    if (!instance) instance = new AuditLogger();
+    return instance;
+}
+
+module.exports = { AuditLogger, getAuditLogger };

package/backend/src/core/logging/StructuredLogger.js

@@ -0,0 +1,80 @@
+const ErrorHandler = require('../errors/ErrorHandler');
+
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    fatal: 4,
+};
+
+class StructuredLogger {
+    constructor({ minLevel = 'info', context = {} } = {}) {
+        this.minLevel = minLevel;
+        this.context = context;
+    }
+
+    _log(level, dataOrMessage, message) {
+        if (LOG_LEVELS[level] < LOG_LEVELS[this.minLevel]) return;
+
+        let data = {};
+        let msg;
+
+        if (message !== undefined) {
+            data = typeof dataOrMessage === 'object' && dataOrMessage !== null ? dataOrMessage : {};
+            msg = message;
+        } else {
+            msg = dataOrMessage;
+        }
+
+        const sanitized = ErrorHandler.sanitize({ ...this.context, ...data });
+
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message: msg,
+            ...sanitized,
+        };
+
+        const output = JSON.stringify(entry);
+
+        if (level === 'fatal' || level === 'error') {
+            console.error(output);
+        } else if (level === 'warn') {
+            console.warn(output);
+        } else if (level === 'debug') {
+            console.debug(output);
+        } else {
+            console.info(output);
+        }
+    }
+
+    debug(dataOrMessage, message) {
+        this._log('debug', dataOrMessage, message);
+    }
+
+    info(dataOrMessage, message) {
+        this._log('info', dataOrMessage, message);
+    }
+
+    warn(dataOrMessage, message) {
+        this._log('warn', dataOrMessage, message);
+    }
+
+    error(dataOrMessage, message) {
+        this._log('error', dataOrMessage, message);
+    }
+
+    fatal(dataOrMessage, message) {
+        this._log('fatal', dataOrMessage, message);
+    }
+
+    child(context) {
+        return new StructuredLogger({
+            minLevel: this.minLevel,
+            context: ErrorHandler.sanitize({ ...this.context, ...context }),
+        });
+    }
+}
+
+module.exports = StructuredLogger;

package/backend/src/core/logging/__tests__/StructuredLogger.test.js

@@ -0,0 +1,213 @@
+const StructuredLogger = require('../StructuredLogger');
+
+describe('StructuredLogger', () => {
+    let logger;
+
+    beforeEach(() => {
+        logger = new StructuredLogger({ minLevel: 'debug' });
+    });
+
+    describe('log output structure', () => {
+        it('includes timestamp, level, and message in every log entry', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info('test message');
+
+            expect(output).toHaveLength(1);
+            expect(output[0]).toMatchObject({
+                level: 'info',
+                message: 'test message',
+            });
+            expect(output[0].timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+        });
+
+        it('accepts (data, message) signature and merges data into entry', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info({ botId: 'bot-1', userId: 'user-1', requestId: 'req-1' }, 'with context');
+
+            expect(output[0]).toMatchObject({
+                level: 'info',
+                message: 'with context',
+                botId: 'bot-1',
+                userId: 'user-1',
+                requestId: 'req-1',
+            });
+        });
+
+        it('accepts (message) signature without data', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info('simple message');
+
+            expect(output[0].message).toBe('simple message');
+        });
+    });
+
+    describe('log levels', () => {
+        it('calls console.debug for debug level', () => {
+            const spy = jest.spyOn(console, 'debug').mockImplementation(() => {});
+            logger.debug('debug msg');
+            expect(spy).toHaveBeenCalled();
+        });
+
+        it('calls console.info for info level', () => {
+            const spy = jest.spyOn(console, 'info').mockImplementation(() => {});
+            logger.info('info msg');
+            expect(spy).toHaveBeenCalled();
+        });
+
+        it('calls console.warn for warn level', () => {
+            const spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+            logger.warn('warn msg');
+            expect(spy).toHaveBeenCalled();
+        });
+
+        it('calls console.error for error level', () => {
+            const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
+            logger.error('error msg');
+            expect(spy).toHaveBeenCalled();
+        });
+
+        it('calls console.error for fatal level', () => {
+            const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
+            logger.fatal('fatal msg');
+            expect(spy).toHaveBeenCalled();
+        });
+    });
+
+    describe('minimum log level filtering', () => {
+        it('suppresses messages below the configured minimum level', () => {
+            const warnLogger = new StructuredLogger({ minLevel: 'warn' });
+            const spy = jest.spyOn(console, 'info').mockImplementation(() => {});
+            const debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => {});
+
+            warnLogger.info('should be suppressed');
+            warnLogger.debug('should be suppressed');
+
+            expect(spy).not.toHaveBeenCalled();
+            expect(debugSpy).not.toHaveBeenCalled();
+        });
+
+        it('outputs messages at or above the minimum level', () => {
+            const warnLogger = new StructuredLogger({ minLevel: 'warn' });
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+            const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+            warnLogger.warn('warn passes');
+            warnLogger.error('error passes');
+            warnLogger.fatal('fatal passes');
+
+            expect(warnSpy).toHaveBeenCalledTimes(1);
+            expect(errorSpy).toHaveBeenCalledTimes(2);
+        });
+
+        it('defaults to info level', () => {
+            const defaultLogger = new StructuredLogger();
+            const debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => {});
+            const infoSpy = jest.spyOn(console, 'info').mockImplementation(() => {});
+
+            defaultLogger.debug('suppressed');
+            defaultLogger.info('passes');
+
+            expect(debugSpy).not.toHaveBeenCalled();
+            expect(infoSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('sensitive data redaction', () => {
+        it('redacts password fields', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info({ password: 'secret123', userId: 'u1' }, 'login attempt');
+
+            expect(output[0].password).toBe('[REDACTED]');
+            expect(output[0].userId).toBe('u1');
+        });
+
+        it('redacts token fields', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info({ token: 'abc123', botId: 'b1' }, 'token check');
+
+            expect(output[0].token).toBe('[REDACTED]');
+            expect(output[0].botId).toBe('b1');
+        });
+
+        it('redacts apiKey fields', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info({ apiKey: 'key-xyz' }, 'api call');
+
+            expect(output[0].apiKey).toBe('[REDACTED]');
+        });
+    });
+
+    describe('child logger', () => {
+        it('creates a child logger with pre-bound context', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            const child = logger.child({ botId: 'bot-42', requestId: 'req-99' });
+            child.info('child message');
+
+            expect(output[0]).toMatchObject({
+                botId: 'bot-42',
+                requestId: 'req-99',
+                message: 'child message',
+            });
+        });
+
+        it('child context is merged with per-call data', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            const child = logger.child({ botId: 'bot-1' });
+            child.info({ userId: 'user-5' }, 'merged');
+
+            expect(output[0]).toMatchObject({
+                botId: 'bot-1',
+                userId: 'user-5',
+                message: 'merged',
+            });
+        });
+
+        it('child inherits parent minLevel', () => {
+            const parent = new StructuredLogger({ minLevel: 'error' });
+            const child = parent.child({ botId: 'b1' });
+            const spy = jest.spyOn(console, 'info').mockImplementation(() => {});
+
+            child.info('should be suppressed');
+
+            expect(spy).not.toHaveBeenCalled();
+        });
+
+        it('redacts sensitive fields in child context', () => {
+            const child = logger.child({ token: 'secret-token', botId: 'b1' });
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            child.info('check redaction');
+
+            expect(output[0].token).toBe('[REDACTED]');
+            expect(output[0].botId).toBe('b1');
+        });
+    });
+
+    describe('output format', () => {
+        it('outputs valid JSON', () => {
+            const rawOutput = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => rawOutput.push(msg));
+
+            logger.info({ botId: 'b1' }, 'json check');
+
+            expect(() => JSON.parse(rawOutput[0])).not.toThrow();
+        });
+    });
+});

package/backend/src/core/logging/index.js

@@ -0,0 +1,7 @@
+const StructuredLogger = require('./StructuredLogger');
+
+const defaultLogger = new StructuredLogger({
+    minLevel: process.env.LOG_LEVEL || 'info',
+});
+
+module.exports = { StructuredLogger, defaultLogger };

package/backend/src/core/metrics/MetricsCollector.js

@@ -0,0 +1,104 @@
+class MetricsCollector {
+    constructor() {
+        this._counters = new Map();
+        this._histograms = new Map();
+        this._gauges = new Map();
+    }
+
+    incrementCounter(name, labels = {}, value = 1) {
+        const key = this._key(name, labels);
+        this._counters.set(key, { name, labels, value: (this._counters.get(key)?.value || 0) + value });
+    }
+
+    recordDuration(name, durationMs, labels = {}) {
+        const key = this._key(name, labels);
+        const existing = this._histograms.get(key) || { name, labels, count: 0, sum: 0, min: Infinity, max: -Infinity, buckets: [] };
+        existing.count++;
+        existing.sum += durationMs;
+        existing.min = Math.min(existing.min, durationMs);
+        existing.max = Math.max(existing.max, durationMs);
+        existing.buckets.push(durationMs);
+        this._histograms.set(key, existing);
+    }
+
+    setGauge(name, value, labels = {}) {
+        const key = this._key(name, labels);
+        this._gauges.set(key, { name, labels, value });
+    }
+
+    getCounter(name, labels = {}) {
+        return this._counters.get(this._key(name, labels))?.value || 0;
+    }
+
+    getHistogram(name, labels = {}) {
+        const h = this._histograms.get(this._key(name, labels));
+        if (!h) return null;
+        const avg = h.count > 0 ? h.sum / h.count : 0;
+        const p50 = this._percentile(h.buckets, 50);
+        const p95 = this._percentile(h.buckets, 95);
+        const p99 = this._percentile(h.buckets, 99);
+        return { count: h.count, sum: h.sum, min: h.min, max: h.max, avg, p50, p95, p99 };
+    }
+
+    getGauge(name, labels = {}) {
+        return this._gauges.get(this._key(name, labels))?.value ?? null;
+    }
+
+    reset() {
+        this._counters.clear();
+        this._histograms.clear();
+        this._gauges.clear();
+    }
+
+    toPrometheus() {
+        const lines = [];
+
+        for (const { name, labels, value } of this._counters.values()) {
+            lines.push(`# TYPE ${name} counter`);
+            lines.push(`${name}${this._labelsStr(labels)} ${value}`);
+        }
+
+        for (const { name, labels, count, sum, min, max } of this._histograms.values()) {
+            lines.push(`# TYPE ${name} histogram`);
+            lines.push(`${name}_count${this._labelsStr(labels)} ${count}`);
+            lines.push(`${name}_sum${this._labelsStr(labels)} ${sum}`);
+            lines.push(`${name}_min${this._labelsStr(labels)} ${min}`);
+            lines.push(`${name}_max${this._labelsStr(labels)} ${max}`);
+        }
+
+        for (const { name, labels, value } of this._gauges.values()) {
+            lines.push(`# TYPE ${name} gauge`);
+            lines.push(`${name}${this._labelsStr(labels)} ${value}`);
+        }
+
+        return lines.join('\n');
+    }
+
+    _key(name, labels) {
+        const labelStr = Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}="${v}"`).join(',');
+        return labelStr ? `${name}{${labelStr}}` : name;
+    }
+
+    _labelsStr(labels) {
+        const entries = Object.entries(labels);
+        if (entries.length === 0) return '';
+        const parts = entries.map(([k, v]) => `${k}="${v}"`).join(',');
+        return `{${parts}}`;
+    }
+
+    _percentile(values, p) {
+        if (values.length === 0) return 0;
+        const sorted = [...values].sort((a, b) => a - b);
+        const idx = Math.ceil((p / 100) * sorted.length) - 1;
+        return sorted[Math.max(0, idx)];
+    }
+}
+
+let instance = null;
+
+function getMetricsCollector() {
+    if (!instance) instance = new MetricsCollector();
+    return instance;
+}
+
+module.exports = { MetricsCollector, getMetricsCollector };

package/backend/src/core/metrics/__tests__/MetricsCollector.test.js

@@ -0,0 +1,131 @@
+const { MetricsCollector } = require('../MetricsCollector');
+
+describe('MetricsCollector', () => {
+    let metrics;
+
+    beforeEach(() => {
+        metrics = new MetricsCollector();
+    });
+
+    describe('counters', () => {
+        it('starts at 0', () => {
+            expect(metrics.getCounter('requests')).toBe(0);
+        });
+
+        it('increments counter', () => {
+            metrics.incrementCounter('requests');
+            metrics.incrementCounter('requests');
+            expect(metrics.getCounter('requests')).toBe(2);
+        });
+
+        it('increments by custom value', () => {
+            metrics.incrementCounter('bytes', {}, 100);
+            metrics.incrementCounter('bytes', {}, 50);
+            expect(metrics.getCounter('bytes')).toBe(150);
+        });
+
+        it('isolates counters by labels', () => {
+            metrics.incrementCounter('requests', { method: 'GET' });
+            metrics.incrementCounter('requests', { method: 'POST' });
+            expect(metrics.getCounter('requests', { method: 'GET' })).toBe(1);
+            expect(metrics.getCounter('requests', { method: 'POST' })).toBe(1);
+        });
+    });
+
+    describe('histograms', () => {
+        it('returns null for unknown histogram', () => {
+            expect(metrics.getHistogram('duration')).toBeNull();
+        });
+
+        it('records duration and computes stats', () => {
+            metrics.recordDuration('duration', 10);
+            metrics.recordDuration('duration', 20);
+            metrics.recordDuration('duration', 30);
+            const h = metrics.getHistogram('duration');
+            expect(h.count).toBe(3);
+            expect(h.sum).toBe(60);
+            expect(h.min).toBe(10);
+            expect(h.max).toBe(30);
+            expect(h.avg).toBe(20);
+        });
+
+        it('computes percentiles', () => {
+            for (let i = 1; i <= 100; i++) metrics.recordDuration('latency', i);
+            const h = metrics.getHistogram('latency');
+            expect(h.p50).toBe(50);
+            expect(h.p95).toBe(95);
+            expect(h.p99).toBe(99);
+        });
+
+        it('isolates histograms by labels', () => {
+            metrics.recordDuration('duration', 10, { route: '/a' });
+            metrics.recordDuration('duration', 20, { route: '/b' });
+            expect(metrics.getHistogram('duration', { route: '/a' }).count).toBe(1);
+            expect(metrics.getHistogram('duration', { route: '/b' }).count).toBe(1);
+        });
+    });
+
+    describe('gauges', () => {
+        it('returns null for unknown gauge', () => {
+            expect(metrics.getGauge('bots')).toBeNull();
+        });
+
+        it('sets and gets gauge value', () => {
+            metrics.setGauge('bots', 5);
+            expect(metrics.getGauge('bots')).toBe(5);
+        });
+
+        it('overwrites gauge value', () => {
+            metrics.setGauge('bots', 5);
+            metrics.setGauge('bots', 3);
+            expect(metrics.getGauge('bots')).toBe(3);
+        });
+
+        it('isolates gauges by labels', () => {
+            metrics.setGauge('bots', 2, { status: 'running' });
+            metrics.setGauge('bots', 1, { status: 'stopped' });
+            expect(metrics.getGauge('bots', { status: 'running' })).toBe(2);
+            expect(metrics.getGauge('bots', { status: 'stopped' })).toBe(1);
+        });
+    });
+
+    describe('reset', () => {
+        it('clears all metrics', () => {
+            metrics.incrementCounter('requests');
+            metrics.recordDuration('duration', 10);
+            metrics.setGauge('bots', 5);
+            metrics.reset();
+            expect(metrics.getCounter('requests')).toBe(0);
+            expect(metrics.getHistogram('duration')).toBeNull();
+            expect(metrics.getGauge('bots')).toBeNull();
+        });
+    });
+
+    describe('toPrometheus', () => {
+        it('outputs counter in Prometheus format', () => {
+            metrics.incrementCounter('http_requests_total', { method: 'GET' }, 3);
+            const output = metrics.toPrometheus();
+            expect(output).toContain('# TYPE http_requests_total counter');
+            expect(output).toContain('http_requests_total{method="GET"} 3');
+        });
+
+        it('outputs histogram in Prometheus format', () => {
+            metrics.recordDuration('request_duration_ms', 100);
+            const output = metrics.toPrometheus();
+            expect(output).toContain('# TYPE request_duration_ms histogram');
+            expect(output).toContain('request_duration_ms_count 1');
+            expect(output).toContain('request_duration_ms_sum 100');
+        });
+
+        it('outputs gauge in Prometheus format', () => {
+            metrics.setGauge('active_bots', 7);
+            const output = metrics.toPrometheus();
+            expect(output).toContain('# TYPE active_bots gauge');
+            expect(output).toContain('active_bots 7');
+        });
+
+        it('returns empty string when no metrics', () => {
+            expect(metrics.toPrometheus()).toBe('');
+        });
+    });
+});