@harperfast/harper 5.0.0-alpha.10 → 5.0.0-beta.1

package/utility/logging/harper_logger.js

@@ -0,0 +1,876 @@
+'use strict';
+
+// Note - do not import/use commonUtils.js in this module, it will cause circular dependencies.
+const fs = require('fs-extra');
+const { workerData, threadId, isMainThread } = require('worker_threads');
+const pathModule = require('path');
+const YAML = require('yaml');
+const PropertiesReader = require('properties-reader');
+const hdbTerms = require('../hdbTerms.ts');
+const assignCMDENVVariables = require('../assignCmdEnvVariables.js');
+const os = require('os');
+const { PACKAGE_ROOT } = require('../../utility/packageUtils.js');
+const { _assignPackageExport } = require('../../globals.js');
+const { Console } = require('console');
+// store the native write function so we can call it after we write to the log file (and store it on process.stdout
+// because unit tests will create multiple instances of this module)
+let nativeStdWrite = process.env.IS_SCRIPTED_SERVICE
+	? function () {
+			// if this is a child process started by a start/restart
+			// command, we can't write to stdout/stderr, we make this a noop
+		}
+	: process.stdout.nativeWrite || (process.stdout.nativeWrite = process.stdout.write);
+let fileLoggers = new Map();
+const { join } = pathModule;
+
+const MAX_LOG_BUFFER = 10000;
+const LOG_LEVEL_HIERARCHY = {
+	notify: 7,
+	fatal: 6,
+	error: 5,
+	warn: 4,
+	info: 3,
+	debug: 2,
+	trace: 1,
+};
+
+const OUTPUTS = {
+	STDOUT: 'stdOut',
+	STDERR: 'stdErr',
+};
+
+// Location of default config YAML.
+const DEFAULT_CONFIG_FILE = join(PACKAGE_ROOT, 'static', hdbTerms.HDB_DEFAULT_CONFIG_FILE);
+
+const CLOSE_LOG_FD_TIMEOUT = 10000;
+
+let logConsole;
+let log_to_file;
+let logToStdstreams;
+let colorMode;
+let logLevel;
+let logName;
+let logRoot;
+let logFilePath;
+let mainLogger;
+let externalLogger; // default logger used for the global used by external components
+let mainLogFd;
+let writeToLogFile;
+let logImmediately;
+
+// If this is the first time logger is called by process, hdb props will be undefined.
+// Call init to get all the required log settings.
+let hdbProperties;
+
+let rootConfig;
+
+function updateLogger(logger, logOptions, name) {
+	logger.rotation = logOptions.rotation;
+	let path = logOptions.path;
+	if (path) {
+		if (!logOptions.root) logOptions.root = pathModule.dirname(path);
+	} else if (logOptions.root) {
+		path = join(logOptions.root, logName);
+	} else {
+		path = mainLogger.path;
+		if (!logOptions.root) logOptions.root = pathModule.dirname(path);
+	}
+	if (path) logger.path = path;
+	else console.error('No path for logger', logOptions);
+	logger.level = LOG_LEVEL_HIERARCHY[logOptions.level] ?? mainLogger?.level ?? LOG_LEVEL_HIERARCHY.info;
+	updateConditional(logger);
+	logger.logToStdstreams = logOptions.stdStreams ?? false;
+	// if there is a configured tag or if a component is logging to default/main log path, use the component name as the tag
+	// to differentiate it
+	logger.tag = logOptions.tag ?? (mainLogger.path === logger.path && name);
+}
+// creates a logger where the methods are only defined if they are within the log level.
+// Using this conditional logger means that every method call must be optional like log.trace?.('message),
+// but there can be performance benefits to using this since it means that the arguments
+// do not need to be evaluated at all.
+function updateConditional(logger) {
+	const conditional = logger.conditional ?? (logger.conditional = {});
+	conditional.notify = LOG_LEVEL_HIERARCHY.notify >= logger.level ? logger.notify.bind(logger) : undefined;
+	conditional.fatal = LOG_LEVEL_HIERARCHY.fatal >= logger.level ? logger.fatal.bind(logger) : undefined;
+	conditional.error = LOG_LEVEL_HIERARCHY.error >= logger.level ? logger.error.bind(logger) : undefined;
+	conditional.warn = LOG_LEVEL_HIERARCHY.warn >= logger.level ? logger.warn.bind(logger) : undefined;
+	conditional.info = LOG_LEVEL_HIERARCHY.info >= logger.level ? logger.info.bind(logger) : undefined;
+	conditional.debug = LOG_LEVEL_HIERARCHY.debug >= logger.level ? logger.debug.bind(logger) : undefined;
+	conditional.trace = LOG_LEVEL_HIERARCHY.trace >= logger.level ? logger.trace.bind(logger) : undefined;
+}
+async function updateLogSettings() {
+	if (!rootConfig) {
+		// set up the initial watcher
+		rootConfig = new RootConfigWatcher();
+		// wait for it to be ready
+		await rootConfig.ready;
+		// TODO: Any way to differentiate changes that we can and can't handle?
+		rootConfig.on('change', updateLogSettings);
+	}
+	let rootConfigObject = rootConfig.config;
+	const logOptions = rootConfigObject.logging ?? {};
+	updateLogger(mainLogger, logOptions);
+	logFilePath = mainLogger.path;
+	logConsole = logOptions.console ?? false;
+	if (logOptions.external) {
+		updateLogger(externalLogger, logOptions.external);
+	}
+	for (const name in rootConfigObject) {
+		// we now scan each component to see if it has logging individual configured
+		const component = rootConfigObject[name];
+		if (component.logging) {
+			updateLogger(mainLogger.forComponent(name), component.logging, name);
+		} else if (mainLogger.hasComponent(name)) {
+			updateLogger(mainLogger.forComponent(name), logOptions, name);
+		}
+	}
+}
+
+class HarperLogger extends Console {
+	constructor(streams, level) {
+		streams.stdout.removeListener = () => {};
+		streams.stderr.removeListener = () => {};
+		streams.stdout.listenerCount = () => {};
+		streams.stderr.listenerCount = () => {};
+		super(streams);
+		this.level = level;
+	}
+	trace(...args) {
+		currentLevel = 'trace';
+		if (this.level <= LOG_LEVEL_HIERARCHY.trace) {
+			super.info(...args);
+		}
+		currentLevel = 'info';
+	}
+	debug(...args) {
+		currentLevel = 'debug';
+		if (this.level <= LOG_LEVEL_HIERARCHY.debug) {
+			super.info(...args);
+		}
+		currentLevel = 'info';
+	}
+	info(...args) {
+		currentLevel = 'info';
+		if (this.level <= LOG_LEVEL_HIERARCHY.info) {
+			super.info(...args);
+		}
+		currentLevel = 'info';
+	}
+	warn(...args) {
+		currentLevel = 'warn';
+		if (this.level <= LOG_LEVEL_HIERARCHY.warn) {
+			super.warn(...args);
+		}
+		currentLevel = 'info';
+	}
+	error(...args) {
+		currentLevel = 'error';
+		if (this.level <= LOG_LEVEL_HIERARCHY.error) {
+			super.error(...args);
+		}
+		currentLevel = 'info';
+	}
+	fatal(...args) {
+		logImmediately = true;
+		try {
+			currentLevel = 'fatal';
+			if (this.level <= LOG_LEVEL_HIERARCHY.fatal) {
+				super.error(...args);
+			}
+			currentLevel = 'info';
+		} finally {
+			logImmediately = false;
+		}
+	}
+	notify(...args) {
+		logImmediately = true;
+		try {
+			currentLevel = 'notify';
+			if (this.level <= LOG_LEVEL_HIERARCHY.notify) {
+				super.info(...args);
+			}
+			currentLevel = 'info';
+		} finally {
+			logImmediately = false;
+		}
+	}
+	withTag(tag) {
+		return loggerWithTag(tag, true, this);
+	}
+	forComponent(_name) {
+		// to be replaced
+		return this;
+	}
+	hasComponent(_name) {
+		// to be replaced
+		return false;
+	}
+}
+
+if (hdbProperties === undefined) initLogSettings();
+
+module.exports = {
+	notify,
+	fatal,
+	error,
+	warn,
+	info,
+	debug,
+	trace,
+	logLevel,
+	loggerWithTag,
+	suppressLogging,
+	initLogSettings,
+	logCustomLevel,
+	closeLogFile,
+	createLogger,
+	logsAtLevel,
+	getLogFilePath: () => logFilePath,
+	forComponent: (name) => mainLogger.forComponent(name),
+	setMainLogger,
+	setLogLevel,
+	OUTPUTS,
+	AuthAuditLog,
+	// for now these functions at least notify us of when the component system is ready so
+	// we can start using the RootConfigWatcher
+	start: updateLogSettings,
+	startOnMainThread: updateLogSettings,
+	errorToString,
+	disableStdio,
+};
+
+/**
+ * We call this if stdio is not functional
+ */
+function disableStdio() {
+	nativeStdWrite = function () {}; // make this a noop
+}
+module.exports.externalLogger = {
+	notify(...args) {
+		externalLogger.notify(...args);
+	},
+	fatal(...args) {
+		externalLogger.fatal(...args);
+	},
+	error(...args) {
+		externalLogger.error(...args);
+	},
+	warn(...args) {
+		externalLogger.warn(...args);
+	},
+	info(...args) {
+		externalLogger.info(...args);
+	},
+	debug(...args) {
+		externalLogger.debug(...args);
+	},
+	trace(...args) {
+		externalLogger.trace(...args);
+	},
+	withTag(tag) {
+		return externalLogger.withTag(tag);
+	},
+	loggerWithTag(tag) {
+		return externalLogger.withTag(tag);
+	},
+};
+_assignPackageExport('logger', module.exports.externalLogger);
+
+/**
+ * Check if the current log level is at or below the given level.
+ * @param level
+ * @return {boolean}
+ */
+function logsAtLevel(level) {
+	return LOG_LEVEL_HIERARCHY[logLevel] <= LOG_LEVEL_HIERARCHY[level];
+}
+
+/**
+ * Get the log settings from the settings file.
+ * If the settings file doesn't exist (during install) check for command or env vars, if there aren't
+ * any, use default values.
+ */
+function initLogSettings(forceInit = false) {
+	try {
+		if (hdbProperties === undefined || forceInit) {
+			closeLogFile();
+			const bootPropsFilePath = getPropsFilePath();
+			let properties = assignCMDENVVariables(['ROOTPATH']);
+			try {
+				hdbProperties = PropertiesReader(bootPropsFilePath);
+			} catch (err) {
+				// This is here for situations where HDB isn't using a boot file
+				if (
+					!properties.ROOTPATH ||
+					(!fs.pathExistsSync(join(properties.ROOTPATH, hdbTerms.HARPER_CONFIG_FILE)) &&
+						!fs.pathExistsSync(join(properties.ROOTPATH, hdbTerms.HDB_CONFIG_FILE)))
+				)
+					throw err;
+			}
+
+			//if root path check for config file, if it exists - all good
+			// if root path and no config file just throw err
+			let configPath;
+			if (properties.ROOTPATH) {
+				configPath = join(properties.ROOTPATH, hdbTerms.HARPER_CONFIG_FILE);
+				if (!fs.pathExistsSync(configPath) && fs.pathExistsSync(join(properties.ROOTPATH, hdbTerms.HDB_CONFIG_FILE)))
+					configPath = join(properties.ROOTPATH, hdbTerms.HDB_CONFIG_FILE);
+			} else configPath = hdbProperties.get('settings_path');
+			let rotation;
+			({
+				level: logLevel,
+				configLogPath: logRoot,
+				toFile: log_to_file,
+				logConsole,
+				colorMode,
+				rotation,
+				toStream: logToStdstreams,
+			} = getLogConfig(configPath));
+
+			logName = hdbTerms.LOG_NAMES.HDB;
+			logFilePath = join(logRoot, logName);
+
+			mainLogger = createLogger({
+				path: logFilePath,
+				level: logLevel,
+				stdStreams: logToStdstreams,
+				rotation,
+			});
+			// setup the external logger
+			externalLogger = mainLogger.forComponent('external');
+			externalLogger.tag = null; // don't tag by default
+			if (isMainThread) {
+				try {
+					const SegfaultHandler = require('segfault-handler');
+					SegfaultHandler.registerHandler(join(logRoot, 'crash.log'));
+				} catch {
+					// optional dependency, ok if we can't run it
+				}
+			}
+		}
+	} catch (err) {
+		hdbProperties = undefined;
+		if (err.code === hdbTerms.NODE_ERROR_CODES.ENOENT || err.code === hdbTerms.NODE_ERROR_CODES.ERR_INVALID_ARG_TYPE) {
+			// If the env settings haven't been initialized check cmd/env vars for values. If values not found used default.
+			const cmdEnvs = assignCMDENVVariables(Object.keys(hdbTerms.CONFIG_PARAM_MAP), true);
+			for (const key in cmdEnvs) {
+				const configParam = hdbTerms.CONFIG_PARAM_MAP[key];
+				if (configParam) configParam.toLowerCase();
+				const configValue = cmdEnvs[key];
+				if (configParam === hdbTerms.CONFIG_PARAMS.LOGGING_LEVEL) {
+					logLevel = configValue;
+					continue;
+				}
+
+				if (configParam === hdbTerms.CONFIG_PARAMS.LOGGING_CONSOLE) {
+					logConsole = configParam;
+				}
+			}
+
+			const { defaultLevel } = getDefaultConfig();
+
+			log_to_file = false;
+			logToStdstreams = true;
+
+			logLevel = logLevel === undefined ? defaultLevel : logLevel;
+
+			mainLogger = createLogger({ level: logLevel });
+			// setup the external logger
+			externalLogger = mainLogger.forComponent('external');
+			externalLogger.tag = null; // don't tag by default
+			return;
+		}
+
+		error('Error initializing log settings');
+		error(err);
+		throw err;
+	}
+	if (process.env.DEV_MODE) logToStdstreams = true;
+	stdioLogging();
+}
+let loggingEnabled = true;
+function stdioLogging() {
+	if (log_to_file) {
+		process.stdout.write = function (data) {
+			if (
+				typeof data === 'string' && // this is how we identify console output vs redirected output from a worker
+				loggingEnabled &&
+				logConsole
+			) {
+				data = data.toString();
+				if (data[data.length - 1] === '\n') data = data.slice(0, -1);
+				writeToLogFile(data);
+			}
+			return nativeStdWrite.apply(process.stdout, arguments);
+		};
+		process.stderr.write = function (data) {
+			if (
+				typeof data === 'string' && // this is how we identify console output vs redirected output from a worker
+				loggingEnabled &&
+				logConsole
+			) {
+				if (data[data.length - 1] === '\n') data = data.slice(0, -1);
+				writeToLogFile(data);
+			}
+			return nativeStdWrite.apply(process.stderr, arguments);
+		};
+	}
+}
+
+function loggerWithTag(tag, conditional, logger = mainLogger) {
+	tag = tag.replace(/ /g, '-'); // tag can't have spaces
+	return {
+		notify: logWithTag(logger.notify, 'notify'),
+		fatal: logWithTag(logger.fatal, 'fatal'),
+		error: logWithTag(logger.error, 'error'),
+		warn: logWithTag(logger.warn, 'warn'),
+		info: logWithTag(logger.info, 'info'),
+		debug: logWithTag(logger.debug, 'debug'),
+		trace: logWithTag(logger.trace, 'trace'),
+	};
+	function logWithTag(loggerMethod, level) {
+		return !conditional || logger.level <= LOG_LEVEL_HIERARCHY[level]
+			? function (...args) {
+					currentTag = tag;
+					try {
+						return loggerMethod.call(logger, ...args);
+					} finally {
+						currentTag = undefined;
+					}
+				}
+			: null;
+	}
+}
+
+function suppressLogging(callback) {
+	try {
+		loggingEnabled = false;
+		callback();
+	} finally {
+		loggingEnabled = true;
+	}
+}
+
+const SERVICE_NAME = workerData?.name?.replace(/ /g, '-') || 'main';
+// these are used to store information about the current service and tag so we can prepend them to the log during
+// the writes, without having to pass the information through the Console instance
+let currentLevel = 'info'; // default is info
+let currentServiceName;
+let currentTag;
+function createLogger({
+	path: logFilePath,
+	level: logLevel,
+	stdStreams: logToStdstreams,
+	rotation,
+	isExternalInstance,
+	writeToLog,
+	component,
+}) {
+	if (!logLevel) logLevel = 'info';
+	let level = LOG_LEVEL_HIERARCHY[logLevel];
+	let logger;
+	/**
+	 * Log to std out and/or file
+	 * @param log
+	 */
+	function logStdOut(log) {
+		if (log_to_file) {
+			if (logger.logToStdstreams) {
+				// eslint-disable-next-line no-control-regex
+				logToFile(log.replace(/\x1b\[[0-9;]*m/g, '')); // remove color codes
+				loggingEnabled = false;
+				try {
+					// if we are writing std streams we don't want to double write to the file through the stdio capture
+					process.stdout.write(log);
+				} finally {
+					loggingEnabled = true;
+				}
+			} else {
+				logToFile(log);
+			}
+		} else if (logToStdstreams) process.stdout.write(log);
+	}
+
+	/**
+	 * Log to std err and/or file
+	 * @param log
+	 */
+	function logStdErr(log) {
+		if (log_to_file) {
+			logToFile(log);
+			if (logToStdstreams) {
+				loggingEnabled = false;
+				try {
+					// if we are writing std streams we don't want to double write to the file through the stdio capture
+					process.stderr.write(log);
+				} finally {
+					loggingEnabled = true;
+				}
+			}
+		} else if (logToStdstreams) process.stderr.write(log);
+	}
+	let logToFile = logFilePath && getFileLogger(logFilePath, rotation, isExternalInstance);
+	function logPrepend(write) {
+		return {
+			write(log) {
+				let tags = [currentLevel];
+				tags.unshift(currentServiceName || SERVICE_NAME + '/' + threadId);
+				if (currentTag) tags.push(currentTag);
+				if (logger.tag) tags.push(logger.tag);
+				write(`[${tags.join('] [')}]: ${log}`);
+			},
+		};
+	}
+	if (isExternalInstance) {
+		writeToLogFile = logToFile;
+	}
+	logger = new HarperLogger(
+		{
+			stdout: logPrepend(writeToLog ?? logStdOut),
+			stderr: logPrepend(writeToLog ?? logStdErr),
+			colorMode: (logToStdstreams && colorMode) || false,
+		},
+		level
+	);
+	updateConditional(logger);
+	logger.path = logFilePath;
+	Object.defineProperty(logger, 'path', {
+		get() {
+			return logFilePath;
+		},
+		set(path) {
+			logFilePath = path;
+			logToFile = getFileLogger(logFilePath, logger.rotation, isExternalInstance);
+			if (isExternalInstance) writeToLogFile = logToFile;
+		},
+		enumerable: true,
+	});
+	logger.closeLogFile = logToFile?.closeLogFile;
+	logger.logToStdstreams = logToStdstreams;
+	if (!component) {
+		let components = new Map();
+		logger.forComponent = function (name) {
+			let componentLogger = components.get(name);
+			if (!componentLogger) {
+				componentLogger = createLogger({
+					path: logFilePath,
+					level: logLevel,
+					stdStreams: logToStdstreams,
+					isExternalInstance: name === 'external',
+					rotation,
+					writeToLog,
+					component: true,
+				});
+				components.set(name, componentLogger);
+			}
+			return componentLogger;
+		};
+		logger.hasComponent = function (name) {
+			return components.has(name);
+		};
+	}
+	return logger;
+}
+const LOG_TIME_USAGE_THRESHOLD = 100;
+/**
+ * Get the file logger for the given path. If it doesn't exist, create it.
+ * @param path
+ * @param isExternalInstance
+ * @return {any}
+ */
+function getFileLogger(path, rotation, isExternalInstance) {
+	let logger = fileLoggers.get(path);
+	let logFD, loggedFDError, logTimer;
+	let logBuffer;
+	let logTimeUsage = 0;
+	if (!logger) {
+		logger = logToFile;
+		logger.closeLogFile = closeLogFile;
+		logger.path = path;
+		fileLoggers.set(path, logger);
+	}
+	if (isMainThread && JSON.stringify(rotation) !== JSON.stringify(logger.rotation)) {
+		logger.rotation = rotation;
+		setTimeout(() => {
+			logger.rotator?.end();
+			if (!rotation) return;
+			const logRotator = require('./logRotator.js');
+			try {
+				logger.rotator = logRotator({
+					logger,
+					...rotation,
+				});
+			} catch (error) {
+				logger('Error initializing log rotator', error);
+			}
+		}, 100);
+	}
+	return logger;
+	function logToFile(log) {
+		let entry = `${new Date().toISOString()} ${log}${log.endsWith('\n') ? '' : '\n'}`;
+		if (logBuffer) {
+			// if we are currently in log buffer mode, we will add the entry to the buffer (there will be a timer to write it)
+			if (logBuffer.length < MAX_LOG_BUFFER) {
+				logBuffer.push(entry);
+			} else if (logBuffer.length === MAX_LOG_BUFFER) {
+				logBuffer.push('Maximum log buffer rate reached, logs will be throttled\n');
+			}
+			if (logImmediately) {
+				clearTimeout(logTimer);
+				logQueuedData();
+			}
+		} else {
+			if (logImmediately || logTimeUsage < performance.now() + LOG_TIME_USAGE_THRESHOLD) {
+				// if we have a directive to log immediately, or we are not using more than 2 percent of processing time
+				logQueuedData(entry);
+			} else {
+				logTimeUsage = Math.min(logTimeUsage, performance.now() + LOG_TIME_USAGE_THRESHOLD);
+				logBuffer = [entry];
+				logTimer = setTimeout(logQueuedData, 1);
+			}
+		}
+	}
+	// this is called on a timer, and will write the log buffer to the file
+	function logQueuedData(entry) {
+		openLogFile();
+		if (logFD) {
+			let startTime = performance.now();
+			fs.appendFileSync(logFD, logBuffer ? logBuffer.join('') : entry);
+			let endTime = performance.now();
+			// determine if we are using more than about two percent of processing time for log writes recently, and if so, we
+			// will start buffering
+			logTimeUsage = Math.max(endTime, logTimeUsage) + (endTime - startTime) * 50;
+		} else if (!loggedFDError) console.log(logBuffer ? logBuffer.join('') : entry);
+		if (logBuffer) logBuffer = null;
+	}
+
+	function closeLogFile() {
+		try {
+			fs.closeSync(logFD);
+		} catch {}
+		logFD = null;
+		if (isExternalInstance) mainLogFd = null;
+	}
+
+	function openLogFile(isRetry) {
+		if (!logFD) {
+			try {
+				logFD = fs.openSync(path, 'a');
+				if (isExternalInstance) mainLogFd = logFD;
+			} catch (error) {
+				if (error.code === 'ENOENT' && !isRetry) {
+					// if the directory doesn't exist, create it
+					fs.mkdirpSync(pathModule.dirname(path));
+					return openLogFile(true);
+				}
+				if (!loggedFDError) {
+					loggedFDError = true;
+					console.error(error);
+				}
+			}
+			setTimeout(() => {
+				closeLogFile();
+			}, CLOSE_LOG_FD_TIMEOUT).unref(); // periodically time it out so we can reset it in case the file has been moved (log rotation or by user) or deleted.
+		}
+	}
+}
+/**
+ * Log an info level log.
+ * @param args - rest parameter syntax (...args), allows function to accept indefinite number of args as an array of log messages(strings/objects).
+ * Provide args separated by commas. No need to stringify objects. Console will do that
+ */
+function info(...args) {
+	mainLogger.info(...args);
+}
+
+/**
+ * Log a trace level log.
+ * @param args - rest parameter syntax (...args), allows function to accept indefinite number of args as an array of log messages(strings/objects).
+ * Provide args separated by commas. No need to stringify objects. Console will do that
+ */
+function trace(...args) {
+	mainLogger.trace(...args);
+}
+
+/**
+ * Log a error level log.
+ * @param args - rest parameter syntax (...args), allows function to accept indefinite number of args as an array of log messages(strings/objects).
+ * Provide args separated by commas. No need to stringify objects. Console will do that
+ */
+function error(...args) {
+	mainLogger.error(...args);
+}
+
+/**
+ * Log a debug level log.
+ * @param args - rest parameter syntax (...args), allows function to accept indefinite number of args as an array of log messages(strings/objects).
+ * Provide args separated by commas. No need to stringify objects. Console will do that
+ */
+function debug(...args) {
+	mainLogger.debug(...args);
+}
+
+/**
+ * Log a notify level log.
+ * @param args - rest parameter syntax (...args), allows function to accept indefinite number of args as an array of log messages(strings/objects).
+ * Provide args separated by commas. No need to stringify objects. Console will do that
+ */
+function notify(...args) {
+	mainLogger.notify(...args);
+}
+
+/**
+ * Log a fatal level log.
+ * @param args - rest parameter syntax (...args), allows function to accept indefinite number of args as an array of log messages(strings/objects).
+ * Provide args separated by commas. No need to stringify objects. Console will do that
+ */
+function fatal(...args) {
+	mainLogger.fatal(...args);
+}
+
+/**
+ * Log a warn level log.
+ * @param args - rest parameter syntax (...args), allows function to accept indefinite number of args as an array of log messages(strings/objects).
+ * Provide args separated by commas. No need to stringify objects. Console will do that
+ */
+function warn(...args) {
+	mainLogger.warn(...args);
+}
+
+function logCustomLevel(level, output, options, ...args) {
+	currentServiceName = options.service_name;
+	try {
+		mainLogger[level](...args);
+	} finally {
+		currentServiceName = undefined;
+	}
+}
+
+/**
+ * This is a duplicate of commonUtils.getPropsFilePath.  We need to have it duplicated here to avoid a circular dependency
+ * that happens when commonUtils is imported.
+ * @returns {*}
+ */
+function getPropsFilePath() {
+	let homeDir = undefined;
+	try {
+		homeDir = os.homedir();
+	} catch {
+		// could get here in android
+		homeDir = process.env.HOME;
+	}
+	if (!homeDir) {
+		homeDir = '~/';
+	}
+
+	let _bootPropsFilePath = join(homeDir, hdbTerms.HDB_HOME_DIR_NAME, hdbTerms.BOOT_PROPS_FILE_NAME);
+	// this checks how we used to store the boot props file for older installations.
+	if (!fs.existsSync(_bootPropsFilePath)) {
+		_bootPropsFilePath = join(PACKAGE_ROOT, 'utility/hdb_boot_properties.file');
+	}
+	return _bootPropsFilePath;
+}
+
+function setLogLevel(level) {
+	logLevel = level;
+}
+
+/**
+ * Reads the harperdb-config.yaml file for log settings.
+ * @param hdbConfigPath
+ * @returns {{configLogPath: any, rotate: any, level: any, toFile: any, root: any, toStream: any}}
+ */
+function getLogConfig(hdbConfigPath) {
+	try {
+		// This is here to accommodate pre 4.0.0 settings files that might exist during upgrade.
+		if (hdbConfigPath.includes('config/settings.js')) {
+			const oldHdbSettings = PropertiesReader(hdbConfigPath);
+			return {
+				level: oldHdbSettings.get(hdbTerms.HDB_SETTINGS_NAMES.LOG_LEVEL_KEY),
+				configLogPath: pathModule.dirname(oldHdbSettings.get(hdbTerms.HDB_SETTINGS_NAMES.LOG_PATH_KEY)),
+				toFile: oldHdbSettings.get(hdbTerms.HDB_SETTINGS_NAMES.LOG_TO_FILE),
+				toStream: oldHdbSettings.get(hdbTerms.HDB_SETTINGS_NAMES.LOG_TO_STDSTREAMS),
+			};
+		}
+		const configDoc = YAML.parseDocument(fs.readFileSync(hdbConfigPath, 'utf8'));
+		const level = configDoc.getIn(['logging', 'level']);
+		const configLogPath = configDoc.getIn(['logging', 'root']);
+		const toFile = configDoc.getIn(['logging', 'file']);
+		const toStream = configDoc.getIn(['logging', 'stdStreams']);
+		const logConsole = configDoc.getIn(['logging', 'console']);
+		const colorMode = configDoc.getIn(['logging', 'colors']) ?? true; // default to true
+		const rotation = configDoc.getIn(['logging', 'rotation'])?.toJSON();
+
+		return {
+			level,
+			configLogPath,
+			toFile,
+			toStream,
+			logConsole,
+			colorMode,
+			rotation,
+		};
+	} catch (err) {
+		// If the config file doesn't exist throw ENOENT error and parent function will use default log settings
+		if (err.code === hdbTerms.NODE_ERROR_CODES.ENOENT) {
+			throw err;
+		}
+
+		console.error('Error accessing config file for logging');
+		console.error(err);
+	}
+}
+
+/**
+ * Read the default harperdb yaml file for default log settings.
+ * Used in early install stages before harperdb-config.yaml exists
+ * @returns {{default_to_file: any, default_level: any, default_to_stream: any}}
+ */
+function getDefaultConfig() {
+	try {
+		const defaultConfigDoc = YAML.parseDocument(fs.readFileSync(DEFAULT_CONFIG_FILE, 'utf8'));
+		const defaultLevel = defaultConfigDoc.getIn(['logging', 'level']);
+		const defaultToFile = defaultConfigDoc.getIn(['logging', 'file']);
+		const defaultToStream = defaultConfigDoc.getIn(['logging', 'stdStreams']);
+		return {
+			defaultLevel,
+			defaultToFile,
+			defaultToStream,
+		};
+	} catch (err) {
+		console.error('Error accessing default config file for logging');
+		console.error(err);
+	}
+}
+
+/**
+ * This converts an error to a human readable string. This follows the convention of standard console logging
+ * of printing the error as "ErrorClassName: message". Strangely, this is _not_ how Error.prototype.toString
+ * behaves, so this normalizes to match the bevahior of the console rather than default toString.
+ * @param error
+ * @return {string|string}
+ */
+function errorToString(error) {
+	return typeof error.message === 'string' ? `${error.constructor.name}: ${error.message}` : error.toString();
+}
+
+function setMainLogger(logger) {
+	mainLogger = logger;
+}
+function closeLogFile() {
+	try {
+		fs.closeSync(mainLogFd);
+	} catch {}
+	mainLogFd = null;
+}
+
+function AuthAuditLog(username, status, type, originatingIp, requestMethod, path) {
+	this.username = username;
+	this.status = status;
+	this.type = type;
+	this.originating_ip = originatingIp;
+	this.request_method = requestMethod;
+	this.path = path;
+}
+// we have to load this at the end to avoid circular dependencies problems
+const { RootConfigWatcher } = require('../../config/RootConfigWatcher.ts');