feat: expose logger and enable configuring it

Expose `$logger` for using when CLI is required as a library. Also introduce `initialize` method in it, that allows full configuration of the log4js instance.
Implement a new `emit-appender` logger, that emits `logData` event with information for the logging instead of printing it to the stdout. This emitter can be used with the following code:

```JavaScript
const tns = require("nativescript");
const { LoggerAppenders } = tns.constants;
const { EventEmitter } = require("events");
const emitter = new EventEmitter();

// IMPORTANT: Due to current log4js behavior, you must set the event handler BEFORE calling initialize of the logger.
emitter.on("logData", logData => {
    // logData contains two properties: loggingEvent and formattedMessage
    // loggingEvent contains information about the level of the message and the raw message itself
    // formattedMessage is the message with specified layout (i.e. it is string). Default layout is `messagePassThrough`.
});

tns.logger.initialize({ appenderOptions: { type: LoggerAppenders.emitAppender, emitter });
```

This is the easiest way to use the new appender. You can also use LoggerLevel from constants and specify different logging levels. You can pass whatever layout you need for the message.

Author: rosen-vladimirov

lib/bootstrap.ts

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

lib/common/definitions/logger.d.ts

@@ -1,18 +1,40 @@
-interface ILogger {
-	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;
+import { Layout, LoggingEvent, Configuration, Level } from "log4js";
+import { EventEmitter } from "events";
+import { LoggerLevel } from "../../constants";
 
-	out(formatStr?: any, ...args: any[]): void;
-	write(...args: any[]): void;
+declare global {
+	interface IAppenderOptions extends IDictionary<any> {
+		type: string;
+	}
 
-	prepare(item: any): string;
-	printInfoMessageOnSameLine(message: string): void;
-	printOnStderr(formatStr?: any, ...args: any[]): void;
+	interface ILoggerOptions {
+		level?: LoggerLevel;
+		appenderOptions?: IAppenderOptions;
+	}
+
+	interface ILogger {
+		initialize(opts?: ILoggerOptions): 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;
+	}
+
+
+	interface Log4JSEmitAppenderConfiguration extends Configuration {
+		layout: Layout;
+		emitter: EventEmitter;
+	}
 }

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

@@ -0,0 +1,38 @@
+import { LoggingEvent } from "log4js";
+import { EventEmitter } from "events";
+
+const logDataEventName = "logData";
+function emitAppender(layout: Function, emitter: EventEmitter) {
+	const appender = (loggingEvent: LoggingEvent) => {
+		emitter.emit(logDataEventName, { loggingEvent, formattedMessage: layout(loggingEvent) });
+	};
+
+	appender.shutdown = () => {
+		emitter.removeAllListeners(logDataEventName);
+	};
+
+	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);
+	}
+
+	if (!config.emitter) {
+		throw new Error("Emitter must be passed to emit-appender");
+	}
+
+	if (!config.emitter.emit || typeof config.emitter.emit !== "function") {
+		throw new Error("The passed emitter must be instance of EventEmitter");
+	}
+
+	// create a new appender instance
+	return emitAppender(layout, config.emitter);
+}
+
+exports.configure = configure;

lib/common/logger.ts

@@ -2,6 +2,7 @@ import * as log4js from "log4js";
 import * as util from "util";
 import * as stream from "stream";
 import * as marked from "marked";
+import { cache } from "./decorators";
 const TerminalRenderer = require("marked-terminal");
 const chalk = require("chalk");
 
@@ -11,26 +12,35 @@ export class Logger implements ILogger {
 	private passwordReplacement = "$1$3*******$2$4";
 	private static LABEL = "[WARNING]:";
 
-	constructor($config: Config.IConfig,
+	constructor(private $config: Config.IConfig,
 		private $options: IOptions) {
-		const appenders: IDictionary<log4js.Appender> = {};
-		const categories: IDictionary<{ appenders: string[]; level: string; }> = {};
-		let level: string = null;
-		if (this.$options.log) {
-			level = this.$options.log;
-		} else {
-			level = $config.DEBUG ? "TRACE" : "INFO";
-		}
+	}
+
+	@cache()
+	public initialize(opts?: ILoggerOptions): void {
+		opts = opts || {};
+		const { appenderOptions: appenderOpts, level } = opts;
 
-		appenders["out"] = {
+		const appender: any = {
 			type: "console",
 			layout: {
 				type: "messagePassThrough"
 			}
 		};
-		categories["default"] = {
-			appenders: ['out'],
-			level
+
+		if (appenderOpts) {
+			_.merge(appender, appenderOpts);
+		}
+
+		const appenders: IDictionary<log4js.Appender> = {
+			out: appender
+		};
+
+		const categories: IDictionary<{ appenders: string[]; level: string; }> = {
+			default: {
+				appenders: ['out'],
+				level: level || (this.$config.DEBUG ? "TRACE" : "INFO")
+			}
 		};
 
 		log4js.configure({ appenders, categories });
@@ -39,42 +49,58 @@ export class Logger implements ILogger {
 	}
 
 	getLevel(): string {
+		this.initialize();
+
 		return this.log4jsLogger.level.toString();
 	}
 
 	fatal(...args: string[]): void {
+		this.initialize();
+
 		this.log4jsLogger.fatal.apply(this.log4jsLogger, args);
 	}
 
 	error(...args: string[]): void {
+		this.initialize();
+
 		const message = util.format.apply(null, args);
 		const colorizedMessage = message.red;
 
 		this.log4jsLogger.error.apply(this.log4jsLogger, [colorizedMessage]);
 	}
 
 	warn(...args: string[]): void {
+		this.initialize();
+
 		const message = util.format.apply(null, args);
 		const colorizedMessage = message.yellow;
 
 		this.log4jsLogger.warn.apply(this.log4jsLogger, [colorizedMessage]);
 	}
 
 	warnWithLabel(...args: string[]): void {
+		this.initialize();
+
 		const message = util.format.apply(null, args);
 		this.warn(`${Logger.LABEL} ${message}`);
 	}
 
 	info(...args: string[]): void {
+		this.initialize();
+
 		this.log4jsLogger.info.apply(this.log4jsLogger, args);
 	}
 
 	debug(...args: string[]): void {
+		this.initialize();
+
 		const encodedArgs: string[] = this.getPasswordEncodedArguments(args);
 		this.log4jsLogger.debug.apply(this.log4jsLogger, encodedArgs);
 	}
 
 	trace(...args: string[]): void {
+		this.initialize();
+
 		const encodedArgs: string[] = this.getPasswordEncodedArguments(args);
 		this.log4jsLogger.trace.apply(this.log4jsLogger, encodedArgs);
 	}

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

@@ -45,6 +45,8 @@ describe("logger", () => {
 			}
 		};
 
+		// Initialize the logger manually, so we can overwrite the log4jsLogger property
+		logger.initialize();
 		logger.log4jsLogger = log4jsLogger;
 	});
 

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

@@ -18,6 +18,7 @@ export class LockServiceStub implements ILockService {
 }
 
 export class CommonLoggerStub implements ILogger {
+	initialize(opts?: ILoggerOptions): void { }
 	getLevel(): string { return undefined; }
 	fatal(...args: string[]): void { }
 	error(...args: string[]): void { }

lib/constants.ts

@@ -1,5 +1,6 @@
 require("colors");
 import { PreviewAppLiveSyncEvents } from "./services/livesync/playground/preview-app-constants";
+import { join } from "path";
 
 export const APP_FOLDER_NAME = "app";
 export const APP_RESOURCES_FOLDER_NAME = "App_Resources";
@@ -299,3 +300,65 @@ export enum IOSNativeTargetTypes {
 	watchExtension = "watch_extension",
 	appExtension = "app_extension"
 }
+
+export const LoggerAppenders = {
+	emitAppender: join(__dirname, "common", "logger-appenders", "emit-appender"),
+};
+
+export enum LoggerLevel {
+	/**
+	 * Show all log messages.
+	 * Log levels are used to assign importance to log messages, with the integer value being used to sort them.
+	 * If you do not specify anything in your configuration, the default values are used (ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < MARK < OFF)
+	 */
+	ALL = "ALL",
+
+	/**
+	 * Log levels are used to assign importance to log messages, with the integer value being used to sort them.
+	 * If you do not specify anything in your configuration, the default values are used (ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < MARK < OFF)
+	 */
+	TRACE = "TRACE",
+
+	/**
+	 * Log levels are used to assign importance to log messages, with the integer value being used to sort them.
+	 * If you do not specify anything in your configuration, the default values are used (ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < MARK < OFF)
+	 */
+	DEBUG = "DEBUG",
+
+	/**
+	 * Log levels are used to assign importance to log messages, with the integer value being used to sort them.
+	 * If you do not specify anything in your configuration, the default values are used (ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < MARK < OFF)
+	 */
+	INFO = "INFO",
+
+	/**
+	 * Log levels are used to assign importance to log messages, with the integer value being used to sort them.
+	 * If you do not specify anything in your configuration, the default values are used (ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < MARK < OFF)
+	 */
+	WARN = "WARN",
+
+	/**
+	 * Log levels are used to assign importance to log messages, with the integer value being used to sort them.
+	 * If you do not specify anything in your configuration, the default values are used (ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < MARK < OFF)
+	 */
+	ERROR = "ERROR",
+
+	/**
+	 * Log levels are used to assign importance to log messages, with the integer value being used to sort them.
+	 * If you do not specify anything in your configuration, the default values are used (ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < MARK < OFF)
+	 */
+	FATAL = "FATAL",
+
+	/**
+	 * Log levels are used to assign importance to log messages, with the integer value being used to sort them.
+	 * If you do not specify anything in your configuration, the default values are used (ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < MARK < OFF)
+	 */
+	MARK = "MARK",
+
+	/**
+	 * Disable all logging.
+	 * Log levels are used to assign importance to log messages, with the integer value being used to sort them.
+	 * If you do not specify anything in your configuration, the default values are used (ALL < TRACE < DEBUG < INFO < WARN < ERROR < FATAL < MARK < OFF)
+	 */
+	OFF = "OFF"
+}

test/nativescript-cli-lib.ts

@@ -23,7 +23,7 @@ describe("nativescript-cli-lib", () => {
 			"getIOSAssetsStructure",
 			"getAndroidAssetsStructure"
 		],
-		constants: ["CONFIG_NS_APP_RESOURCES_ENTRY", "CONFIG_NS_APP_ENTRY", "CONFIG_NS_FILE_NAME"],
+		constants: ["CONFIG_NS_APP_RESOURCES_ENTRY", "CONFIG_NS_APP_ENTRY", "CONFIG_NS_FILE_NAME", "LoggerLevel", "LoggerAppenders"],
 		localBuildService: ["build"],
 		deviceLogProvider: null,
 		packageManager: ["install", "uninstall", "view", "search"],
@@ -62,6 +62,11 @@ describe("nativescript-cli-lib", () => {
 		],
 		cleanupService: [
 			"setCleanupLogFile"
+		],
+		logger: [
+			"initialize",
+			"getLevel",
+			"info"
 		]
 	};
 

test/stubs.ts

@@ -11,6 +11,7 @@ import { HostInfo } from "./../lib/common/host-info";
 import { DevicePlatformsConstants } from "./../lib/common/mobile/device-platforms-constants";
 
 export class LoggerStub implements ILogger {
+	initialize(opts?: ILoggerOptions): void { }
 	getLevel(): string { return undefined; }
 	fatal(...args: string[]): void { }
 	error(...args: string[]): void { }