@fc3/mmcadi 0.1.0

package/src/lib/logger/enum/log-level.ts

@@ -0,0 +1,8 @@
+enum LogLevel {
+	ERROR = 'error',
+	INFO = 'info',
+	SUCCESS = 'success',
+	WARNING = 'warning'
+}
+
+export default LogLevel;

package/src/lib/logger/formatter.ts

@@ -0,0 +1,59 @@
+/**
+ * This class is useful mostly for dev. It wraps messages in the necessary
+ * ANSI codes for color-coding certain messages based on log level.
+ */
+
+import LogLevel from 'lib/logger/enum/log-level';
+import AnsiEscapeCode from 'lib/logger/enum/ansi-escape-code';
+
+class LogFormatter {
+	private message: string;
+	private log_level: LogLevel;
+
+	public constructor(message: string, log_level: LogLevel) {
+		this.message = message;
+		this.log_level = log_level;
+	}
+
+	public format(): string {
+		const message = this.getMessage();
+		const log_level = this.getLogLevel();
+
+		if (log_level === LogLevel.INFO) {
+			return message;
+		}
+
+		const escape_code = this.getAnsiEscapeCodeForLogLevel(log_level);
+		const reset_code = this.getAnsiResetCode();
+
+		return `${escape_code}${message}${reset_code}`;
+	}
+
+	private getAnsiEscapeCodeForLogLevel(log_level: LogLevel): AnsiEscapeCode {
+		switch (log_level) {
+			case LogLevel.SUCCESS:
+				return AnsiEscapeCode.GREEN;
+			case LogLevel.WARNING:
+				return AnsiEscapeCode.YELLOW;
+			case LogLevel.ERROR:
+				return AnsiEscapeCode.RED;
+			case LogLevel.INFO:
+			default:
+				return AnsiEscapeCode.WHITE;
+		}
+	}
+
+	private getAnsiResetCode(): AnsiEscapeCode {
+		return AnsiEscapeCode.RESET;
+	}
+
+	private getMessage(): string {
+		return this.message;
+	}
+
+	private getLogLevel(): LogLevel {
+		return this.log_level;
+	}
+}
+
+export default LogFormatter;

package/src/lib/logger/index.ts

@@ -0,0 +1,7 @@
+import Logger from 'lib/logger/logger';
+
+export {default as LogLevel} from 'lib/logger/enum/log-level';
+export {default as LoggableData} from 'lib/logger/type/loggable-data';
+export {default as LoggerInterface} from 'lib/logger/interface/logger';
+
+export default Logger;

package/src/lib/logger/interface/error-reporter.ts

@@ -0,0 +1,7 @@
+import ErrorParameters from 'lib/logger/type/error-parameters';
+
+interface ErrorReporter {
+	notify(message: string, parameters: ErrorParameters): void;
+}
+
+export default ErrorReporter;

package/src/lib/logger/interface/logger.ts

@@ -0,0 +1,13 @@
+import LogLevel from 'lib/logger/enum/log-level';
+import LoggableData from 'lib/logger/type/loggable-data';
+
+interface LoggerInterface {
+	setRemoteAddress(remote_address: string): LoggerInterface;
+	error(message: Error | string | LoggableData): void;
+	warn(message: string | LoggableData): void;
+	info(message: string | LoggableData): void;
+	success(message: string | LoggableData): void;
+	writeMessage(message: string, log_level: LogLevel): void;
+}
+
+export default LoggerInterface;

package/src/lib/logger/logger.ts

@@ -0,0 +1,239 @@
+/**
+ * The Logger class is exactly what it sounds like: you can use it to log
+ * messages from the Node.js environment. Please use this instead of calling
+ * console.log() or process.stdout.write(), etc.
+ *
+ * In development, the Logger class will pretty-print output logs for you
+ * to view in the console. In production, the Logger will print JSON-formatted
+ * message objects.
+ */
+
+import {EventEmitter} from 'events';
+
+import {isProductionOrStaging} from 'lib/environment';
+import Feature from 'lib/feature';
+
+import LogLevel from 'lib/logger/enum/log-level';
+import LogFormatter from 'lib/logger/formatter';
+import LoggableData from 'lib/logger/type/loggable-data';
+import ErrorReporter from 'lib/logger/interface/error-reporter';
+import LoggerInterface from 'lib/logger/interface/logger';
+import {LoggableValue} from 'lib/logger/type/loggable-value';
+
+class Logger extends EventEmitter implements LoggerInterface {
+	private static error_reporter: ErrorReporter | undefined;
+
+	public static setErrorReporter(
+		error_reporter: ErrorReporter | undefined
+	): void {
+		this.error_reporter = error_reporter;
+	}
+
+	public static getErrorReporter(): ErrorReporter {
+		if (this.error_reporter === undefined) {
+			throw new Error('Tried to read error reporter, but it was not set');
+		}
+
+		return this.error_reporter;
+	}
+
+	public static hasErrorReporter(): boolean {
+		return this.error_reporter !== undefined;
+	}
+
+	private unique_id: string | undefined;
+	private remote_address: string | undefined;
+	private origin: string | undefined;
+
+	public constructor() {
+		super();
+
+		this.bindHandlers();
+	}
+
+	public setUniqueId(unique_id: string): this {
+		this.unique_id = unique_id;
+		return this;
+	}
+
+	public setRemoteAddress(remote_address: string): this {
+		this.remote_address = remote_address;
+		return this;
+	}
+
+	public setOrigin(origin: string): this {
+		this.origin = origin;
+		return this;
+	}
+
+	public error(message: Error | string): void {
+		if (message instanceof Error) {
+			message = message.toString();
+		}
+
+		return void this.writeMessage(message, LogLevel.ERROR);
+	}
+
+	public warn(message: string | LoggableData): void {
+		return void this.writeMessage(message, LogLevel.WARNING);
+	}
+
+	public info(message: string | LoggableData): void {
+		return void this.writeMessage(message, LogLevel.INFO);
+	}
+
+	public success(message: string | LoggableData): void {
+		return void this.writeMessage(message, LogLevel.SUCCESS);
+	}
+
+	public writeMessage(body: string | LoggableData, log_level: LogLevel): void {
+		const unique_id = this.getUniqueId();
+		const remote_address = this.getRemoteAddress();
+		const origin = this.getOrigin();
+		const timestamp = Date.now();
+
+		const message = {
+			unique_id,
+			remote_address,
+			origin,
+			timestamp,
+			log_level
+		};
+
+		if (typeof body === 'string') {
+			Object.assign(message, {
+				body
+			});
+		} else {
+			Object.assign(message, body);
+		}
+
+		if (log_level === LogLevel.ERROR && this.shouldReportErrors()) {
+			this.reportError(message);
+		}
+
+		const serialized_message = this.serializeMessage(message);
+
+		process.stdout.write(`${serialized_message}\n`);
+	}
+
+	public errorAndExit(error: string | Error): void {
+		this.error(error);
+
+		if (error instanceof Error && error.stack !== undefined) {
+			this.error(error.stack);
+		}
+
+		process.exit(1);
+	}
+
+	public successAndExit(message: string): void {
+		this.success(message);
+		process.exit(0);
+	}
+
+	private bindHandlers(): void {
+		this.errorAndExit = this.errorAndExit.bind(this);
+		this.successAndExit = this.successAndExit.bind(this);
+	}
+
+	private getUniqueId(): string | undefined {
+		return this.unique_id;
+	}
+
+	private getRemoteAddress(): string | undefined {
+		return this.remote_address;
+	}
+
+	private getOrigin(): string | undefined {
+		return this.origin;
+	}
+
+	private shouldLogAsJson(): boolean {
+		if (!Feature.isEnabled('logger.json_logging')) {
+			return false;
+		}
+
+		return isProductionOrStaging();
+	}
+
+	private serializeMessage(message: LoggableData): string {
+		if (this.shouldLogAsJson()) {
+			return this.serializeMessageAsJson(message);
+		} else {
+			return this.serializeMessageAsHumanReadableText(message);
+		}
+	}
+
+	private serializeMessageAsJson(message: LoggableData): string {
+		const trimmed_message = this.trimExtraWhitespaceFromMessage(message);
+
+		return JSON.stringify(trimmed_message);
+	}
+
+	private serializeMessageAsHumanReadableText(message: LoggableData): string {
+		const text = this.trimExtraWhitespaceFromLoggableValue(message.body);
+		const id = message.unique_id || message.remote_address;
+
+		const parts = [];
+
+		parts.push(`[${message.timestamp}]`);
+
+		if (id) {
+			parts.push(`[${id}]`);
+		}
+
+		parts.push(text);
+
+		const formatted_message = parts.join(' ');
+
+		const formatter = new LogFormatter(
+			formatted_message,
+			message.log_level as LogLevel
+		);
+
+		return formatter.format();
+	}
+
+	private trimExtraWhitespaceFromMessage(
+		input_message: LoggableData
+	): LoggableData {
+		const result: LoggableData = {};
+
+		for (const key in input_message) {
+			const value = input_message[key];
+
+			result[key] = this.trimExtraWhitespaceFromLoggableValue(value);
+		}
+
+		return result;
+	}
+
+	private trimExtraWhitespaceFromLoggableValue(
+		value: LoggableValue
+	): LoggableValue {
+		if (typeof value !== 'string') {
+			return value;
+		}
+
+		return value.replace(/\s+/g, ' ').trim();
+	}
+
+	private shouldReportErrors(): boolean {
+		if (!Logger.hasErrorReporter()) {
+			return false;
+		}
+
+		return isProductionOrStaging();
+	}
+
+	private reportError(error: LoggableData): void {
+		Logger.getErrorReporter().notify(error.message as string, {
+			meta_data: {
+				unique_id: error.unique_id
+			}
+		});
+	}
+}
+
+export default Logger;

package/src/lib/logger/type/error-parameters.ts

@@ -0,0 +1,9 @@
+import {LoggableValue} from 'lib/logger/type/loggable-value';
+
+interface ErrorParameters {
+	meta_data: {
+		[key: string]: LoggableValue;
+	};
+}
+
+export default ErrorParameters;

package/src/lib/logger/type/loggable-data.ts

@@ -0,0 +1,5 @@
+import {LoggableValue} from 'lib/logger/type/loggable-value';
+
+export default interface LoggableData {
+	[key: string]: LoggableValue;
+}

package/src/lib/logger/type/loggable-value.ts

@@ -0,0 +1 @@
+export type LoggableValue = string | number | undefined | null;

package/src/lib/metrics/dispatcher.ts

@@ -0,0 +1,264 @@
+/**
+ * This class is a wrapper around the StatsD calls that we need to make
+ * from a Node.js process in order to power things like Datadog dashboards, etc.
+ *
+ * It basically exists to provide an abstract interface over the `node-statsd`
+ * third-party library.
+ */
+
+import {StatsD as StatsdClient} from 'node-statsd';
+
+import Logger from 'lib/logger';
+import {isProduction} from 'lib/environment';
+import Feature from 'lib/feature';
+
+import TagMap from 'lib/metrics/type/tag-map';
+import DispatchMode from 'lib/metrics/enum/dispatch-mode';
+import SettingsHydrator from 'lib/metrics/settings-hydrator';
+import DispatcherSettings from 'lib/metrics/type/dispatcher-settings';
+
+class MetricsDispatcher {
+	private static instance: MetricsDispatcher;
+
+	public static getInstance(): MetricsDispatcher {
+		if (this.instance === undefined) {
+			this.instance = new MetricsDispatcher();
+		}
+
+		return this.instance;
+	}
+
+	public static setInstance(instance: MetricsDispatcher): void {
+		if (this.instance) {
+			this.instance.disconnect();
+		}
+
+		this.instance = instance;
+	}
+
+	private settings: DispatcherSettings;
+	private client: StatsdClient | undefined;
+	private logger: Logger | undefined;
+
+	public constructor(partial_settings?: Partial<DispatcherSettings>) {
+		if (partial_settings === undefined) {
+			partial_settings = {};
+		}
+
+		const hydrator = new SettingsHydrator(partial_settings);
+
+		this.settings = hydrator.hydrate();
+	}
+
+	public mute(): this {
+		this.setDispatchMode(DispatchMode.MUTED);
+
+		return this;
+	}
+
+	public unmute(): this {
+		this.setDispatchMode(DispatchMode.UNMUTED);
+
+		return this;
+	}
+
+	public gauge(metric_name: string, value: number, tags?: TagMap): this {
+		const prepared_tags = this.prepareTags(metric_name, tags);
+
+		this.getClient().gauge(metric_name, value, prepared_tags);
+
+		return this;
+	}
+
+	public increment(metric_name: string, amount?: number, tags?: TagMap): this {
+		if (amount === undefined) {
+			amount = 1;
+		} else if (amount < 0) {
+			throw new Error(
+				`Must specify positive amount to increment (got ${amount})`
+			);
+		}
+
+		const prepared_tags = this.prepareTags(metric_name, tags);
+
+		this.getClient().increment(metric_name, amount, prepared_tags);
+
+		return this;
+	}
+
+	public decrement(metric_name: string, amount?: number, tags?: TagMap): this {
+		if (amount === undefined) {
+			amount = -1;
+		} else if (amount > 0) {
+			throw new Error(
+				`Must specify negative value to decrement (got ${amount})`
+			);
+		}
+
+		const prepared_tags = this.prepareTags(metric_name, tags);
+
+		this.getClient().decrement(metric_name, amount * -1, prepared_tags);
+
+		return this;
+	}
+
+	public timing(
+		metric_name: string,
+		milliseconds: number,
+		tags?: TagMap
+	): this {
+		const prepared_tags = this.prepareTags(metric_name, tags);
+
+		this.getClient().timing(metric_name, milliseconds, prepared_tags);
+
+		return this;
+	}
+
+	public disconnect(): void {
+		if (this.client) {
+			this.client.close();
+		}
+	}
+
+	private getClient(): StatsdClient {
+		if (!this.client) {
+			this.client = this.createClient();
+		}
+
+		return this.client;
+	}
+
+	private createClient(): StatsdClient {
+		const client_properties = {
+			host: this.getHost(),
+			port: this.getPort(),
+			// eslint-disable-next-line @typescript-eslint/naming-convention
+			cacheDns: this.shouldCacheDns(),
+			mock: this.shouldMock()
+		};
+
+		const client = new StatsdClient(client_properties);
+
+		// Manually unref the underlying UDP socket to allow the process to close
+		// even if the StatsD connection is still open.
+		// TODO: Should we use ShutdownManager hooks for this instead?
+		client.socket.unref();
+
+		return client;
+	}
+
+	private getHost(): string {
+		const settings = this.getSettings();
+
+		return settings.host;
+	}
+
+	private getPort(): number {
+		const settings = this.getSettings();
+
+		return settings.port;
+	}
+
+	private getDispatchMode(): DispatchMode {
+		const settings = this.getSettings();
+
+		return settings.dispatch_mode;
+	}
+
+	private setDispatchMode(dispatch_mode: DispatchMode): void {
+		const settings = this.getSettings();
+
+		this.settings = {
+			...settings,
+			dispatch_mode
+		};
+	}
+
+	private getTags(): TagMap {
+		const settings = this.getSettings();
+
+		return settings.tags;
+	}
+
+	private getSettings(): DispatcherSettings {
+		return this.settings;
+	}
+
+	private prepareTags(
+		metric_name: string,
+		ephemeral_tags: TagMap | undefined
+	): string[] {
+		if (!Feature.isEnabled('metric_tags')) {
+			if (ephemeral_tags === undefined) {
+				return [];
+			}
+
+			// Just because these are very noisy:
+			switch (metric_name) {
+				case 'incoming_responses':
+				case 'outgoing_responses':
+				case 'incoming_response_time':
+				case 'outgoing_response_time':
+					return [];
+			}
+
+			const tag_keys = Object.keys(ephemeral_tags);
+
+			if (tag_keys.length > 0) {
+				const logger = this.getLogger();
+				const serialized_tags = tag_keys.join(', ');
+
+				logger.warn(`
+					Metric tags are disabled!
+					Received the following tags for metric "${metric_name}":
+					${serialized_tags}
+				`);
+			}
+
+			return [];
+		}
+
+		const persistent_tags = this.getTags();
+
+		if (ephemeral_tags === undefined) {
+			return this.concatenateTags(persistent_tags);
+		}
+
+		const combined_tags = this.combineTags(persistent_tags, ephemeral_tags);
+
+		return this.concatenateTags(combined_tags);
+	}
+
+	private combineTags(persistent_tags: TagMap, ephemeral_tags: TagMap): TagMap {
+		const result = {};
+
+		Object.assign(result, persistent_tags);
+		Object.assign(result, ephemeral_tags);
+
+		return result as TagMap;
+	}
+
+	private concatenateTags(tags: TagMap): string[] {
+		return Object.keys(tags).map((key) => {
+			return `${key}:${tags[key]}`;
+		});
+	}
+
+	private shouldCacheDns(): boolean {
+		return isProduction();
+	}
+
+	private shouldMock(): boolean {
+		return this.getDispatchMode() === DispatchMode.MUTED;
+	}
+
+	private getLogger(): Logger {
+		if (this.logger === undefined) {
+			this.logger = new Logger();
+		}
+
+		return this.logger;
+	}
+}
+
+export default MetricsDispatcher;

package/src/lib/metrics/enum/dispatch-mode.ts

@@ -0,0 +1,6 @@
+enum DispatchMode {
+	MUTED = 'muted',
+	UNMUTED = 'unmuted'
+}
+
+export default DispatchMode;

package/src/lib/metrics/index.ts

@@ -0,0 +1,2 @@
+export {default as TagMap} from 'lib/metrics/type/tag-map';
+export {default as Dispatcher} from 'lib/metrics/dispatcher';

package/src/lib/metrics/settings-hydrator.ts

@@ -0,0 +1,51 @@
+import TagMap from 'lib/metrics/type/tag-map';
+import DispatchMode from 'lib/metrics/enum/dispatch-mode';
+import DispatcherSettings from 'lib/metrics/type/dispatcher-settings';
+
+class SettingsHydrator {
+	private partial_settings: Partial<DispatcherSettings>;
+
+	public constructor(partial_settings: Partial<DispatcherSettings>) {
+		this.partial_settings = partial_settings;
+	}
+
+	public hydrate(): DispatcherSettings {
+		const partial_settings = this.getPartialSettings();
+		const host = this.getDefaultHost();
+		const port = this.getDefaultPort();
+		const tags = this.getDefaultTags();
+		const dispatch_mode = this.getDefaultDispatchMode();
+		const prefix = '';
+
+		return {
+			host,
+			port,
+			tags,
+			dispatch_mode,
+			prefix,
+			...partial_settings
+		};
+	}
+
+	private getDefaultHost(): string {
+		return 'localhost';
+	}
+
+	private getDefaultPort(): number {
+		return 1234;
+	}
+
+	private getDefaultTags(): TagMap {
+		return {};
+	}
+
+	private getDefaultDispatchMode(): DispatchMode {
+		return DispatchMode.UNMUTED;
+	}
+
+	private getPartialSettings(): Partial<DispatcherSettings> {
+		return this.partial_settings;
+	}
+}
+
+export default SettingsHydrator;

package/src/lib/metrics/type/dispatcher-settings.ts

@@ -0,0 +1,12 @@
+import TagMap from 'lib/metrics/type/tag-map';
+import DispatchMode from 'lib/metrics/enum/dispatch-mode';
+
+interface DispatcherSettings {
+	readonly host: string;
+	readonly port: number;
+	readonly prefix: string;
+	readonly tags: TagMap;
+	readonly dispatch_mode: DispatchMode;
+}
+
+export default DispatcherSettings;

package/src/lib/metrics/type/tag-map.ts

@@ -0,0 +1,5 @@
+interface TagMap {
+	[key: string]: string | number;
+}
+
+export default TagMap;

package/src/lib/network/bootstrap.ts

@@ -0,0 +1 @@
+throw new Error('Not implemented');