New log model.

dleclercpro · dleclercpro · commit db5eba2c8e78 · 2023-10-05T22:40:41.000+02:00
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "berlin-lea-performance-monitor",
-  "version": "1.14.0",
+  "version": "1.15.0",
   "author": "David Leclerc",
   "main": "./src/index.ts",
   "scripts": {
diff --git a/src/Log.ts b/src/Log.ts
@@ -0,0 +1,101 @@
+import Release from './models/Release';
+
+type Args = {
+    line: number,
+    level: number,
+    time: Date,
+    version: Release,
+    processId: number,
+    hostname: string,
+    message: string,
+    error?: string,
+}
+
+class Log {
+    private line: number;
+    private level: number;
+    private time: Date;
+    private version: Release;
+    private processId: number;
+    private hostname: string;
+    private message: string;
+    private error?: string;
+
+    constructor(args: Args) {
+        const { line, level, time, version, processId, hostname, message, error } = args;
+
+        this.line = line;
+        this.level = level;
+        this.time = time;
+        this.version = version;
+        this.processId = processId;
+        this.hostname = hostname;
+        this.message = message;
+        this.error = error;
+    }
+
+    public static fromText(line: string, index: number) {
+        const { level, time, version, pid, hostname, msg, err } = JSON.parse(line);
+
+        return new Log({
+            line: index + 1,
+            level,
+            time: new Date(time),
+            version: Release.fromString(version),
+            processId: pid,
+            hostname,
+            message: msg,
+            error: err,
+        });
+    }
+
+    public static isLineValid(line: string) {
+        return line.startsWith('{') && line.endsWith('}');
+    }
+
+    public toString() {
+        return (`{` +
+            `"level":${this.level},` +
+            `"time":"${this.time}",` +
+            `"pid":${this.processId},` +
+            `"hostname":"${this.hostname}",` +
+            `"version":"${this.version.toString()}",` +
+            (this.error ? `"err":"${this.error}",` : '') +
+            `"msg":"${this.message}"` +
+        `}`);
+    }
+
+    public getLine() {
+        return this.line;
+    }
+
+    public getLevel() {
+        return this.level;
+    }
+
+    public getTime() {
+        return this.time;
+    }
+
+    public getVersion() {
+        return this.version;
+    }
+
+    public hasMessage() {
+        return !!this.message;
+    }
+
+    public getMessage() {
+        return this.message;
+    }
+
+    public hasError() {
+        return !!this.error;
+    }
+
+    public getError() {
+        return this.error;
+    }
+}
+
+export default Log;
diff --git a/src/models/jobs/AnalysisJob.ts b/src/models/jobs/AnalysisJob.ts
@@ -37,6 +37,11 @@ class AnalysisJob extends Job {
     public async execute() {
         const logs = await this.getLogsToAnalyze();
 
+        if (logs.length === 0) {
+            logger.info(`No logs to analyze.`);
+            return;
+        }
+
         const hourlyHistory = SessionHistoryBuilder.build(logs, ONE_HOUR);
         const biHourlyHistory = SessionHistoryBuilder.rebuildWithDifferentBucketSize(hourlyHistory, new TimeDuration(2, TimeUnit.Hours));
     
diff --git a/src/models/logs/LogRotater.ts b/src/models/logs/LogRotater.ts
@@ -1,11 +1,11 @@
 import { writeFileSync } from 'fs';
 import { LOGS_DIR, LOGS_FILEPATH } from '../../config/file';
-import { Log } from '../../types';
 import { formatDateForFilename } from '../../utils/locale';
-import { logToText, parseLogs } from '../../utils/parsing';
+import { parseLogs } from '../../utils/parsing';
 import { getMidnightInUTC } from '../../utils/time';
 import logger from '../../logger';
 import { NEW_LINE } from '../../constants';
+import Log from '../../Log';
 
 type LogFiles = Record<string, Log[]>;
 
@@ -36,7 +36,7 @@ class LogRotater {
 
         // Differentiate between logs in the past, and logs today
         logs.forEach((log: Log) => {
-            const date = new Date(log.time);
+            const date = log.getTime();
             const filepath = this.getFilepathForDate(date);
 
             // Ignore today's logs: they stay in the default 'app.log'
@@ -54,7 +54,9 @@ class LogRotater {
 
         // Store previous days in individual log files
         for (const [filepath, logs] of Object.entries(prevFiles)) {
-            const data = logs.map(logToText).join(NEW_LINE) + NEW_LINE;
+            const data = logs
+                .map(log => log.toString())
+                .join(NEW_LINE) + NEW_LINE;
 
             // Write synchronously to avoid other parts of the code
             // logging to the default output file during rotation
@@ -63,7 +65,9 @@ class LogRotater {
 
         // Overwrite default output log file 'app.log' with only
         // logs from current day
-        const dataFromToday = nextFiles[this.getFilepathForDate(now)].map(logToText).join(NEW_LINE) + NEW_LINE;
+        const dataFromToday = nextFiles[this.getFilepathForDate(now)]
+            .map(log => log.toString())
+            .join(NEW_LINE) + NEW_LINE;
 
         writeFileSync(LOGS_FILEPATH, dataFromToday);
 
diff --git a/src/models/sessions/CompleteSession.ts b/src/models/sessions/CompleteSession.ts
@@ -59,7 +59,7 @@ class CompleteSession extends Session implements Comparable {
     // The session was completed, no error was detected, and the success
     // message was logged: there seems to be an appointment available!
     public wasSuccess() {
-        const logMessages = this.logs.map(log => log.msg);
+        const logMessages = this.logs.map(log => log.getMessage());
 
         return (
             !this.error &&
diff --git a/src/models/sessions/IncompleteSession.ts b/src/models/sessions/IncompleteSession.ts
@@ -1,8 +1,8 @@
-import { Log } from '../../types';
 import os from 'os';
 import process from 'process';
 import crypto from 'crypto';
 import Session from './Session';
+import Log from '../../Log';
 
 class IncompleteSession extends Session {
     protected errors: string[] = [];
@@ -43,12 +43,10 @@ class IncompleteSession extends Session {
     }
 
     public push(log: Log) {
-        const { err } = log;
-
         this.logs.push(log);
 
-        if (err) {
-            this.errors.push(err);
+        if (log.hasError()) {
+            this.errors.push(log.getError()!);
         }
     }
 }
diff --git a/src/models/sessions/Session.ts b/src/models/sessions/Session.ts
@@ -1,4 +1,4 @@
-import { Log } from '../../types';
+import Log from '../../Log';
 
 export interface SessionArgs {
     id: string,
diff --git a/src/models/sessions/SessionHistoryBuilder.ts b/src/models/sessions/SessionHistoryBuilder.ts
@@ -1,5 +1,5 @@
 import logger from '../../logger';
-import { Log, TimeUnit, Weekday } from '../../types';
+import { TimeUnit, Weekday } from '../../types';
 import IncompleteSession from './IncompleteSession';
 import SessionHistory from './SessionHistory';
 import CompleteSession from './CompleteSession';
@@ -8,6 +8,7 @@ import TimeDuration from '../units/TimeDuration';
 import { getRange } from '../../utils/math';
 import SessionBucket from '../buckets/SessionBucket';
 import { formatDateForFilename } from '../../utils/locale';
+import Log from '../../Log';
 
 const TEXTS = {
     SessionStart: '[START]',
@@ -40,11 +41,11 @@ class SessionHistoryBuilder {
         logs.forEach(log => {
 
             // Session started
-            if (log.msg.includes(TEXTS.SessionStart)) {
+            if (log.getMessage().includes(TEXTS.SessionStart)) {
                 session = IncompleteSession.create();
 
-                logger.trace(`Starting session: ${session.getId()} [${log.version.toJSON()}]`);
-                session.start(new Date(log.time));
+                logger.trace(`Starting session: ${session.getId()} [${log.getVersion().toJSON()}]`);
+                session.start(log.getTime());
             }
 
             // Session exists and is open: store log
@@ -53,9 +54,9 @@ class SessionHistoryBuilder {
             }
 
             // Session ended
-            if (log.msg.includes(TEXTS.SessionEnd)) {
-                logger.trace(`Finishing session: ${session.getId()} [${log.version.toJSON()}]`);
-                session.end(new Date(log.time));
+            if (log.getMessage().includes(TEXTS.SessionEnd)) {
+                logger.trace(`Finishing session: ${session.getId()} [${log.getVersion().toJSON()}]`);
+                session.end(log.getTime());
 
                 // Sessions should have a start and an end
                 if (!session.isComplete()) {
@@ -65,15 +66,15 @@ class SessionHistoryBuilder {
                 // Has session more than one error: it is invalid!
                 const errorCount = session.getErrors().length;
                 if (errorCount > 1) {
-                    const sessionStartLine = session.getLogs()[0].line;
-                    logger.warn(`Invalid session [${formatDateForFilename(session.getStartTime()!)} @${sessionStartLine}] with ${errorCount} > 1 errors found`);
+                    const sessionStartLine = session.getLogs()[0].getLine();
+                    logger.warn(`Invalid session [${formatDateForFilename(session.getStartTime()!)} @${sessionStartLine}] with (${errorCount} > 1) errors found`);
                     return;
                 }
 
                 // Store complete session in history
                 history.addSession(new CompleteSession({
                     id: session.getId(),
-                    release: log.version,
+                    release: log.getVersion(),
                     startTime: session.getStartTime()!,
                     endTime: session.getEndTime()!,
                     logs: session.getLogs(),
diff --git a/src/models/sessions/SessionHistoryExporter.ts b/src/models/sessions/SessionHistoryExporter.ts
@@ -3,7 +3,6 @@ import logger from '../../logger';
 import { getLastValue } from '../../utils/array';
 import { writeFile } from '../../utils/file';
 import { sum } from '../../utils/math';
-import { logToText } from '../../utils/parsing';
 import CompleteSession from './CompleteSession';
 import SessionHistory from './SessionHistory';
 
@@ -35,7 +34,7 @@ class SessionHistoryExporter {
         
         const lines = history.getSessions()
             .reduce((prevLogs: string[], session: CompleteSession) => {
-                const newLogs = [...prevLogs, ...session.getLogs().map(logToText)];
+                const newLogs = [...prevLogs, ...session.getLogs().map(log => log.toString())];
 
                 logger.debug(`Converted ${newLogs.length} logs to string.`);
 
diff --git a/src/types.ts b/src/types.ts
@@ -1,5 +1,3 @@
-import Release from "./models/Release";
-
 export enum Environment {
     Development = 'development',
     Test = 'test',
@@ -78,15 +76,4 @@ export interface Comparable {
     greaterThan(other: Comparable): boolean;
 }
 
-export type CountsDict = Record<string, number>;
-
-export type Log = {
-    line: number,
-    time: string,
-    version: Release,
-    level: number,
-    pid: number,
-    hostname: string,
-    msg: string,
-    err?: string,
-};
+export type CountsDict = Record<string, number>;
diff --git a/src/utils/parsing.ts b/src/utils/parsing.ts
@@ -1,43 +1,11 @@
+import Log from '../Log';
 import { NEW_LINE_REGEXP } from '../constants';
 import logger from '../logger';
 import Release from '../models/Release';
-import { Log } from '../types';
 import { readFile } from './file';
 
 
 
-const isTextLog = (line: string) => {
-    return line.startsWith('{') && line.endsWith('}');
-}
-
-const hasLogMessage = (log: Log) => {
-    return !!log && !!log.msg;
-}
-
-export const textToLog = (line: string, i: number): Log => {
-    const { version, ...log } = JSON.parse(line);
-    return {
-        ...log,
-        line: i + 1,
-        version: Release.fromString(version),
-    };
-}
-
-export const logToText = (log: Log) => {
-    return (`{` +
-        `"level":${log.level},` +
-        `"time":"${log.time}",` +
-        `"pid":${log.pid},` +
-        `"hostname":"${log.hostname}",` +
-        `"version":"${log.version.toString()}",` +
-        (log.err ? `"err":"${log.err}",` : '') +
-        `"msg":"${log.msg}"` +
-        `}`
-    );
-};
-
-
-
 export const parseLogs = async (filepath: string, since?: Date | Release) => {
     logger.trace(`Reading logs...`);
 
@@ -53,18 +21,18 @@ export const parseLogs = async (filepath: string, since?: Date | Release) => {
 
     const logs: Log[] = file
         .split(NEW_LINE_REGEXP)
-        .filter(isTextLog)
-        .map(textToLog)
+        .filter((line: string) => Log.isLineValid(line))
+        .map((line: string, index: number) => Log.fromText(line, index))
         .filter((log: Log) => {
             if (since instanceof Date) {
-                return new Date(log.time) >= since;
+                return log.getTime() >= since;
             }
             if (since instanceof Release) {
-                return log.version.greaterThanOrEquals(since);
+                return log.getVersion().greaterThanOrEquals(since);
             }
             return true;
         })
-        .filter(hasLogMessage); // Every log should have a message
+        .filter((log: Log) => log.hasMessage());
 
     if (logs.length > 0) {
         logger.debug(`Parsed ${logs.length} valid log entries.`);

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "berlin-lea-performance-monitor",`
`3`		`- "version": "1.14.0",`
	`3`	`+ "version": "1.15.0",`
`4`	`4`	`"author": "David Leclerc",`
`5`	`5`	`"main": "./src/index.ts",`
`6`	`6`	`"scripts": {`
Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,8 @@`
`1`		`-import { Log } from '../../types';`
`2`	`1`	`import os from 'os';`
`3`	`2`	`import process from 'process';`
`4`	`3`	`import crypto from 'crypto';`
`5`	`4`	`import Session from './Session';`
	`5`	`+import Log from '../../Log';`
`6`	`6`
`7`	`7`	`class IncompleteSession extends Session {`
`8`	`8`	`protected errors: string[] = [];`
`@@ -43,12 +43,10 @@ class IncompleteSession extends Session {`
`43`	`43`	`}`
`44`	`44`
`45`	`45`	`public push(log: Log) {`
`46`		`- const { err } = log;`
`47`		`-`
`48`	`46`	`this.logs.push(log);`
`49`	`47`
`50`		`- if (err) {`
`51`		`- this.errors.push(err);`
	`48`	`+ if (log.hasError()) {`
	`49`	`+ this.errors.push(log.getError()!);`
`52`	`50`	`}`
`53`	`51`	`}`
`54`	`52`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-import { Log } from '../../types';`
	`1`	`+import Log from '../../Log';`
`2`	`2`
`3`	`3`	`export interface SessionArgs {`
`4`	`4`	`id: string,`