feat: use only log4js methods in CLI logger

Refactor the logic in CLI's logger to use log4js methods only - currently we have some methods that use `console.log`, others use `process.stdout`, `process.stderr`, etc.
Also, there are some methods that apply console colorization for the message, but in fact CLI may be used as a library or in CI, where these colorization does not make sense.
To resolve this, introduce a new appender and new layout that CLI will pass to `log4js`.
The appender (called `cli-appender`) will control if the message will be shown on `stdout` or `stderr`.
The layout (called `cli-layout`) will control the presentation of the message on the terminal, i.e. if we should add new line at the end of the message, if we should wrap it in borders (with `*` symbols, etc.) and the colorization of the message.
The layout will be applied on all methods, so you can use it with any log4js method, i.e. you can do:
```TypeScript
this.$logger.warn("This is my message", { useStderr: true });
this.$logger.info("This is my message", { useStderr: true });
```

Before passing the data to `log4js`, CLI will set required properties in the context of the logging event, so the appender and the layout can read them.

This way, in case CLI is used as a library, the custom properties and CLI specific layout, will not be shown.

Also delete some methods from logger API, so it is streamlined. Also change logger.error to print on stderr instead of stdout.
Move logger.ts to logger directory, so all logger logic will be on a single place.

Author: rosen-vladimirov

lib/bootstrap.ts

@@ -1,5 +1,5 @@
 require("./common/bootstrap");
-$injector.requirePublicClass("logger", "./common/logger");
+$injector.requirePublicClass("logger", "./common/logger/logger");
 $injector.require("config", "./config");
 $injector.require("options", "./options");
 // note: order above is important!

lib/common/definitions/logger.d.ts

@@ -14,22 +14,16 @@ declare global {
 
 	interface ILogger {
 		initialize(opts?: ILoggerOptions): void;
+		initializeCliLogger(): void;
 		getLevel(): string;
 		fatal(formatStr?: any, ...args: any[]): void;
 		error(formatStr?: any, ...args: any[]): void;
 		warn(formatStr?: any, ...args: any[]): void;
-		warnWithLabel(formatStr?: any, ...args: any[]): void;
 		info(formatStr?: any, ...args: any[]): void;
 		debug(formatStr?: any, ...args: any[]): void;
 		trace(formatStr?: any, ...args: any[]): void;
 		printMarkdown(...args: any[]): void;
-
-		out(formatStr?: any, ...args: any[]): void;
-		write(...args: any[]): void;
-
 		prepare(item: any): string;
-		printInfoMessageOnSameLine(message: string): void;
-		printOnStderr(formatStr?: any, ...args: any[]): void;
 	}
 
 

lib/common/logger/appenders/cli-appender.ts

@@ -0,0 +1,29 @@
+import { LoggingEvent } from "log4js";
+import { LoggerConfigData } from "../../../constants";
+
+function cliAppender(layout: Function) {
+	const appender = (loggingEvent: LoggingEvent) => {
+		if (loggingEvent && loggingEvent.data) {
+			const stream = loggingEvent.context[LoggerConfigData.useStderr] ? process.stderr : process.stdout;
+			const preparedData = layout(loggingEvent);
+			stream.write(preparedData);
+		}
+	};
+
+	return appender;
+}
+
+function configure(config: Log4JSEmitAppenderConfiguration, layouts: any) {
+	// the default layout for the appender
+	let layout = layouts.messagePassThroughLayout;
+
+	// check if there is another layout specified
+	if (config.layout) {
+		layout = layouts.layout(config.layout.type, config.layout);
+	}
+
+	// create a new appender instance
+	return cliAppender(layout);
+}
+
+exports.configure = configure;

lib/common/logger-appenders/emit-appender.ts renamed to lib/common/logger/appenders/emit-appender.ts

@@ -1,14 +1,14 @@
 import { LoggingEvent } from "log4js";
 import { EventEmitter } from "events";
+import { EmitAppenderEventName } from "../../../constants";
 
-const logDataEventName = "logData";
 function emitAppender(layout: Function, emitter: EventEmitter) {
 	const appender = (loggingEvent: LoggingEvent) => {
-		emitter.emit(logDataEventName, { loggingEvent, formattedMessage: layout(loggingEvent) });
+		emitter.emit(EmitAppenderEventName, { loggingEvent, formattedMessage: layout(loggingEvent) });
 	};
 
 	appender.shutdown = () => {
-		emitter.removeAllListeners(logDataEventName);
+		emitter.removeAllListeners(EmitAppenderEventName);
 	};
 
 	return appender;

lib/common/logger/layouts/cli-layout.ts

@@ -0,0 +1,33 @@
+import { format } from "util";
+import { getMessageWithBorders } from "../../helpers";
+import { LoggingEvent } from "log4js";
+import { LoggerConfigData, LoggerLevel } from "../../../constants";
+import { EOL } from "os";
+
+export function layout(config: any) {
+	return function (logEvent: LoggingEvent): string {
+		let msg = format.apply(null, logEvent.data);
+
+		if (logEvent.context[LoggerConfigData.wrapMessageWithBorders]) {
+			msg = getMessageWithBorders(msg);
+		}
+
+		if (!logEvent.context[LoggerConfigData.skipNewLine]) {
+			msg += EOL;
+		}
+
+		if (logEvent.level.isEqualTo(LoggerLevel.INFO)) {
+			return msg;
+		}
+
+		if (logEvent.level.isEqualTo(LoggerLevel.ERROR)) {
+			return msg.red.bold;
+		}
+
+		if (logEvent.level.isEqualTo(LoggerLevel.WARN)) {
+			return msg.yellow;
+		}
+
+		return msg;
+	};
+}

lib/common/logger.ts renamed to lib/common/logger/logger.ts

@@ -2,15 +2,16 @@ import * as log4js from "log4js";
 import * as util from "util";
 import * as stream from "stream";
 import * as marked from "marked";
-import { cache } from "./decorators";
+import { cache } from "../decorators";
+import { layout } from "./layouts/cli-layout";
+import { LoggerConfigData, LoggerLevel, LoggerAppenders } from "../../constants";
 const TerminalRenderer = require("marked-terminal");
 const chalk = require("chalk");
 
 export class Logger implements ILogger {
 	private log4jsLogger: log4js.Logger = null;
 	private passwordRegex = /(password=).*?(['&,]|$)|(password["']?\s*:\s*["']).*?(["'])/i;
 	private passwordReplacement = "$1$3*******$2$4";
-	private static LABEL = "[WARNING]:";
 
 	constructor(private $config: Config.IConfig,
 		private $options: IOptions) {
@@ -48,68 +49,49 @@ export class Logger implements ILogger {
 		this.log4jsLogger = log4js.getLogger();
 	}
 
-	getLevel(): string {
-		this.initialize();
+	public initializeCliLogger(): void {
+		log4js.addLayout("cli", layout);
 
-		return this.log4jsLogger.level.toString();
+		this.initialize({
+			appenderOptions: { type: LoggerAppenders.cliAppender, layout: { type: "cli" } },
+			level: <any>this.$options.log
+		});
 	}
 
-	fatal(...args: string[]): void {
+	getLevel(): string {
 		this.initialize();
 
-		this.log4jsLogger.fatal.apply(this.log4jsLogger, args);
+		return this.log4jsLogger.level.toString();
 	}
 
-	error(...args: string[]): void {
-		this.initialize();
-
-		const message = util.format.apply(null, args);
-		const colorizedMessage = message.red;
-
-		this.log4jsLogger.error.apply(this.log4jsLogger, [colorizedMessage]);
+	fatal(...args: any[]): void {
+		this.logMessage(args, LoggerLevel.FATAL);
 	}
 
-	warn(...args: string[]): void {
-		this.initialize();
-
-		const message = util.format.apply(null, args);
-		const colorizedMessage = message.yellow;
-
-		this.log4jsLogger.warn.apply(this.log4jsLogger, [colorizedMessage]);
+	error(...args: any[]): void {
+		args.push({ [LoggerConfigData.useStderr]: true });
+		this.logMessage(args, LoggerLevel.ERROR);
 	}
 
-	warnWithLabel(...args: string[]): void {
-		this.initialize();
-
-		const message = util.format.apply(null, args);
-		this.warn(`${Logger.LABEL} ${message}`);
+	warn(...args: any[]): void {
+		this.logMessage(args, LoggerLevel.WARN);
 	}
 
-	info(...args: string[]): void {
-		this.initialize();
-
-		this.log4jsLogger.info.apply(this.log4jsLogger, args);
+	info(...args: any[]): void {
+		this.logMessage(args, LoggerLevel.INFO);
 	}
 
-	debug(...args: string[]): void {
-		this.initialize();
-
+	debug(...args: any[]): void {
 		const encodedArgs: string[] = this.getPasswordEncodedArguments(args);
-		this.log4jsLogger.debug.apply(this.log4jsLogger, encodedArgs);
+		this.logMessage(encodedArgs, LoggerLevel.DEBUG);
 	}
 
-	trace(...args: string[]): void {
-		this.initialize();
-
+	trace(...args: any[]): void {
 		const encodedArgs: string[] = this.getPasswordEncodedArguments(args);
-		this.log4jsLogger.trace.apply(this.log4jsLogger, encodedArgs);
-	}
-
-	out(...args: string[]): void {
-		console.log(util.format.apply(null, args));
+		this.logMessage(encodedArgs, LoggerLevel.TRACE);
 	}
 
-	write(...args: string[]): void {
+	write(...args: any[]): void {
 		process.stdout.write(util.format.apply(null, args));
 	}
 
@@ -133,12 +115,6 @@ export class Logger implements ILogger {
 		return JSON.stringify(item);
 	}
 
-	public printInfoMessageOnSameLine(message: string): void {
-		if (!this.$options.log || this.$options.log === "info") {
-			this.write(message);
-		}
-	}
-
 	public printMarkdown(...args: string[]): void {
 		const opts = {
 			unescape: true,
@@ -160,13 +136,53 @@ export class Logger implements ILogger {
 		marked.setOptions({ renderer: new TerminalRenderer(opts) });
 
 		const formattedMessage = marked(util.format.apply(null, args));
-		this.write(formattedMessage);
+		this.info(formattedMessage, { [LoggerConfigData.skipNewLine]: true });
 	}
 
-	public printOnStderr(...args: string[]): void {
-		if (process.stderr) {
-			process.stderr.write(util.format.apply(null, args));
+	private logMessage(inputData: any[], logMethod: string): void {
+		this.initialize();
+
+		const logOpts = this.getLogOptionsForMessage(inputData);
+		const data = logOpts.data;
+		delete logOpts.data;
+
+		for (const prop in logOpts) {
+			this.log4jsLogger.addContext(prop, logOpts[prop]);
 		}
+
+		(<IDictionary<any>>this.log4jsLogger)[logMethod.toLowerCase()].apply(this.log4jsLogger, data);
+
+		for (const prop in logOpts) {
+			this.log4jsLogger.removeContext(prop);
+		}
+	}
+
+	private getLogOptionsForMessage(data: any[]): { data: any[], [key: string]: any } {
+		const opts = _.keys(LoggerConfigData);
+
+		const result: any = {};
+		const cleanedData = _.cloneDeep(data);
+
+		const dataToCheck = data.filter(el => typeof el === "object");
+
+		for (const element of dataToCheck) {
+			if (opts.length === 0) {
+				break;
+			}
+
+			const remainingOpts = _.cloneDeep(opts);
+			for (const prop of remainingOpts) {
+				const hasProp = element && element.hasOwnProperty(prop);
+				if (hasProp) {
+					opts.splice(opts.indexOf(prop), 1);
+					result[prop] = element[prop];
+					cleanedData.splice(cleanedData.indexOf(element), 1);
+				}
+			}
+		}
+
+		result.data = cleanedData;
+		return result;
 	}
 
 	private getPasswordEncodedArguments(args: string[]): string[] {

lib/common/test/unit-tests/logger.ts

@@ -1,5 +1,5 @@
 import { Yok } from "../../yok";
-import { Logger } from "../../logger";
+import { Logger } from "../../logger/logger";
 import * as path from "path";
 import { assert } from "chai";
 import * as fileSystemFile from "../../file-system";

lib/common/test/unit-tests/stubs.ts

@@ -2,6 +2,7 @@
 
 import * as util from "util";
 import { EventEmitter } from "events";
+import { LoggerConfigData } from "../../../constants";
 
 export class LockServiceStub implements ILockService {
 	public async lock(lockFilePath?: string, lockOpts?: ILockOptions): Promise<() => void> {
@@ -19,43 +20,31 @@ export class LockServiceStub implements ILockService {
 
 export class CommonLoggerStub implements ILogger {
 	initialize(opts?: ILoggerOptions): void { }
+	initializeCliLogger(): void { }
 	getLevel(): string { return undefined; }
-	fatal(...args: string[]): void { }
-	error(...args: string[]): void { }
-	warn(...args: string[]): void {
-		this.out.apply(this, args);
+	fatal(...args: any[]): void { }
+	error(...args: any[]): void { }
+	warn(...args: any[]): void {
+		this.output += util.format.apply(null, args) + "\n";
 	}
-	warnWithLabel(...args: string[]): void { }
-	info(...args: string[]): void {
-		this.out.apply(this, args);
+	info(...args: any[]): void {
+		this.output += util.format.apply(null, args) + "\n";
 	}
-	debug(...args: string[]): void { }
-	trace(...args: string[]): void {
+	debug(...args: any[]): void { }
+	trace(...args: any[]): void {
 		this.traceOutput += util.format.apply(null, args) + "\n";
 	}
 
 	public output = "";
 	public traceOutput = "";
 
-	out(...args: string[]): void {
-		this.output += util.format.apply(null, args) + "\n";
-	}
-
-	write(...args: string[]): void { }
-
 	prepare(item: any): string {
 		return "";
 	}
 
-	printInfoMessageOnSameLine(message: string): void { }
-
 	printMarkdown(message: string): void {
 		this.output += message;
 	}
-
-	printOnStderr(...args: string[]): void {
-		// nothing to do here
-	}
 }
 
 export class ErrorsStub implements IErrors {
@@ -168,7 +157,7 @@ export class DeviceLogProviderStub extends EventEmitter implements Mobile.IDevic
 	public currentDeviceProjectNames: IStringDictionary = {};
 
 	logData(line: string, platform: string, deviceIdentifier: string): void {
-		this.logger.write(line, platform, deviceIdentifier);
+		this.logger.info(line, platform, deviceIdentifier, { [LoggerConfigData.skipNewLine]: true });
 	}
 
 	setLogLevel(level: string, deviceIdentifier?: string): void {

lib/constants.ts

@@ -301,8 +301,10 @@ export enum IOSNativeTargetTypes {
 	appExtension = "app_extension"
 }
 
+const pathToLoggerAppendersDir = join(__dirname, "common", "logger", "appenders");
 export const LoggerAppenders = {
-	emitAppender: join(__dirname, "common", "logger-appenders", "emit-appender"),
+	emitAppender: join(pathToLoggerAppendersDir, "emit-appender"),
+	cliAppender: join(pathToLoggerAppendersDir, "cli-appender")
 };
 
 export enum LoggerLevel {
@@ -362,3 +364,11 @@ export enum LoggerLevel {
 	 */
 	OFF = "OFF"
 }
+
+export enum LoggerConfigData {
+	useStderr = "useStderr",
+	wrapMessageWithBorders = "wrapMessageWithBorders",
+	skipNewLine = "skipNewLine"
+}
+
+export const EMIT_APPENDER_EVENT_NAME = "logData";