accounts-frontend/packages/app/services/logger/abbreviate.ts

const STRING_MAX_LENGTH = 128 * 1024;

type Filter = (key: string | undefined, value: Record<string, any>) => any;

interface State {
    sizeLeft: number;
}

/**
 * Create a copy of any object without non-serializable elements to make result safe for JSON.stringify().
 * Guaranteed to never throw.
 *
 * @param {any}    obj     Any data structure
 * @param {object} options
 * @param {Function=} options.filter - callback that is called on every object's key with (key,value) and should return
 *        value to use (may return undefined to remove unwanted keys). See nodeFilter and browserFilter.
 * @param {number=} options.depth - maximum recursion depth. Elements deeper than that are stringified with util.inspect()
 * @param {number=} options.maxSize - roughly maximum allowed size of data after JSON serialisation (but it's not guaranteed
 *        that it won't exceed the limit)
 *
 * @see https://github.com/ftlabs/js-abbreviate
 *
 * @returns {object}
 */
function abbreviate(
    obj: Record<string, any>,
    options: {
        filter?: Filter;
        depth?: number;
        maxSize?: number;
    } = {},
): string {
    const filter: Filter = options.filter || ((key, value) => value);
    const maxDepth: number = options.depth || 10;
    const maxSize: number = options.maxSize || 1 * 1024 * 1024;

    return abbreviateRecursive(undefined, obj, filter, { sizeLeft: maxSize }, maxDepth);
}

function limitStringLength(str: string): string {
    if (str.length > STRING_MAX_LENGTH) {
        return `${str.substring(0, STRING_MAX_LENGTH / 2)} … ${str.substring(str.length - STRING_MAX_LENGTH / 2)}`;
    }

    return str;
}

function abbreviateRecursive(key: string | undefined, obj: any, filter: Filter, state: State, maxDepth: number): any {
    // TODO: return type
    if (state.sizeLeft < 0) {
        return '**skipped**';
    }

    state.sizeLeft -= 5; // rough approximation of JSON overhead

    obj = filter(key, obj);

    try {
        switch (typeof obj) {
            case 'object': {
                if (obj === null) {
                    return null;
                }

                if (maxDepth < 0) {
                    break; // fall back to stringification
                }

                const newobj: Record<string, any> | Array<any> = Array.isArray(obj) ? [] : {};

                for (const i in obj) {
                    if (!obj.hasOwnProperty(i)) {
                        continue;
                    }

                    // @ts-ignore
                    newobj[i] = abbreviateRecursive(i, obj[i], filter, state, maxDepth - 1);

                    if (state.sizeLeft < 0) {
                        break;
                    }
                }

                return newobj;
            }

            case 'string':
                obj = limitStringLength(obj);
                state.sizeLeft -= obj.length;

                return obj;

            case 'number':
            case 'boolean':
            case 'undefined':
            default:
                return obj;
        }
    } catch (err) {
        /* fall back to inspect*/
    }

    try {
        obj = limitStringLength(`${obj}`);
        state.sizeLeft -= obj.length;

        return obj;
    } catch (err) {
        return '**non-serializable**';
    }
}

function commonFilter(key: any, val: any): any {
    if (typeof val === 'function') {
        return undefined;
    }

    if (val instanceof Date) {
        return `**Date** ${val}`;
    }

    if (val instanceof Error) {
        const err = {
            // These properties are implemented as magical getters and don't show up in for in
            stack: val.stack,
            message: val.message,
            name: val.name,
        };

        for (const i in val) {
            if (!val.hasOwnProperty(i)) {
                continue;
            }

            // @ts-ignore
            err[i] = val[i];
        }

        return err;
    }

    return val;
}

function nodeFilter(key: any, val: any): any {
    // domain objects are huge and have circular references
    if (key === 'domain' && typeof val === 'object' && val._events) {
        return '**domain ignored**';
    }

    if (key === 'domainEmitter') {
        return '**domainEmitter ignored**';
    }

    if (val === global) {
        return '**global**';
    }

    return commonFilter(key, val);
}

function browserFilter(key: any, val: any): any {
    if (val === window) {
        return '**window**';
    }

    if (val === document) {
        return '**document**';
    }

    if (val instanceof HTMLElement) {
        const { outerHTML } = val;

        if (typeof outerHTML !== 'undefined') {
            return `**HTMLElement** ${outerHTML}`;
        }
    }

    return commonFilter(key, val);
}

export { abbreviate, nodeFilter, browserFilter };

export default function (obj: any): string {
    return abbreviate(obj, {
        filter: browserFilter,
    });
}