daemon-log.ts

import { ILogger, LogLevel } from '@theia/core/lib/common/logger';

export interface DaemonLog {
    readonly time: string;
    readonly level: DaemonLog.Level;
    readonly msg: string;
}

export namespace DaemonLog {
    export interface Url {
        readonly Scheme: string;
        readonly Host: string;
        readonly Path: string;
    }

    export namespace Url {
        export function is(arg: any | undefined): arg is Url {
            return (
                !!arg &&
                typeof arg.Scheme === 'string' &&
                typeof arg.Host === 'string' &&
                typeof arg.Path === 'string'
            );
        }

        export function toString(url: Url): string {
            const { Scheme, Host, Path } = url;
            return `${Scheme}://${Host}${Path}`;
        }
    }

    export interface System {
        readonly os: string;
        // readonly Resource: Resource;
    }

    export namespace System {
        export function toString(system: System): string {
            return `OS: ${system.os}`;
        }
    }

    export interface Tool {
        readonly version: string;
        readonly systems: System[];
    }

    export namespace Tool {
        export function is(arg: any | undefined): arg is Tool {
            return !!arg && typeof arg.version === 'string' && 'systems' in arg;
        }

        export function toString(tool: Tool): string {
            const { version, systems } = tool;
            return `Version: ${version}${
                !!systems
                    ? ` Systems: [${tool.systems
                          .map(System.toString)
                          .join(', ')}]`
                    : ''
            }`;
        }
    }

    export type Level = 'trace' | 'debug' | 'info' | 'warning' | 'error';

    export function is(arg: any | undefined): arg is DaemonLog {
        return (
            !!arg &&
            typeof arg.time === 'string' &&
            typeof arg.level === 'string' &&
            typeof arg.msg === 'string'
        );
    }

    export function toLogLevel(log: DaemonLog): LogLevel {
        const { level } = log;
        switch (level) {
            case 'trace':
                return LogLevel.TRACE;
            case 'debug':
                return LogLevel.DEBUG;
            case 'info':
                return LogLevel.INFO;
            case 'warning':
                return LogLevel.WARN;
            case 'error':
                return LogLevel.ERROR;
            default:
                return LogLevel.INFO;
        }
    }

    export function log(logger: ILogger, logMessages: string): void {
        const parsed = parse(logMessages);
        for (const log of parsed) {
            const logLevel = toLogLevel(log);
            const message = toMessage(log, { omitLogLevel: true });
            logger.log(logLevel, message);
        }
    }

    function parse(toLog: string): DaemonLog[] {
        const messages = toLog.trim().split('\n');
        const result: DaemonLog[] = [];
        for (let i = 0; i < messages.length; i++) {
            try {
                const maybeDaemonLog = JSON.parse(messages[i]);
                if (DaemonLog.is(maybeDaemonLog)) {
                    result.push(maybeDaemonLog);
                    continue;
                }
            } catch {
                /* NOOP */
            }
            result.push({
                time: new Date().toString(),
                level: 'info',
                msg: messages[i],
            });
        }
        return result;
    }

    export function toPrettyString(logMessages: string): string {
        const parsed = parse(logMessages);
        return parsed.map((log) => toMessage(log)).join('\n') + '\n';
    }

    function toMessage(
        log: DaemonLog,
        options: { omitLogLevel: boolean } = { omitLogLevel: false }
    ): string {
        const details = Object.keys(log)
            .filter((key) => key !== 'msg' && key !== 'level' && key !== 'time')
            .map((key) => toDetails(log, key))
            .join(', ');
        const logLevel = options.omitLogLevel
            ? ''
            : `[${log.level.toUpperCase()}] `;
        return `${logLevel}${log.msg}${!!details ? ` [${details}]` : ''}`;
    }

    function toDetails(log: DaemonLog, key: string): string {
        let value = (log as any)[key];
        if (DaemonLog.Url.is(value)) {
            value = DaemonLog.Url.toString(value);
        } else if (DaemonLog.Tool.is(value)) {
            value = DaemonLog.Tool.toString(value);
        } else if (typeof value === 'object') {
            value = JSON.stringify(value).replace(/\"([^(\")"]+)\":/g, '$1:'); // Remove the quotes from the property keys.
        }
        return `${key.toLowerCase()}: ${value}`;
    }
}