barracuda-client-api/src/logging/index.ts

API Client to connect to Barracuda Enterprise Service Bus

/* tslint:disable */

export enum loglevels {
  none,
  error,
  warn,
  info,
  http,
  debug,
  verbose,
  silly,
}

export type LogLevelStrings = keyof typeof loglevels;
let logLevelKeys: LogLevelStrings[] = [];

export function LogLevelKeys(): LogLevelStrings[] {
  if (logLevelKeys.length === 0) {
    logLevelKeys = Object.keys(loglevels)
      .filter(v => !(parseInt(v, 10) >= 0)) as LogLevelStrings[];
  }
  return logLevelKeys;
}

export function GenerateLogLevelMap(): { [p: string]: loglevels } {
  return (LogLevelKeys())
    .reduce((previousValue, currentValue) => {
      previousValue[currentValue] = loglevels[currentValue];
      previousValue[currentValue.toLocaleUpperCase()] = loglevels[currentValue];
      previousValue[currentValue.toLocaleLowerCase()] = loglevels[currentValue];
      return previousValue;
    }, {} as { [p: string]: loglevels });
}

export const logLevelByString: { [ll: string]: loglevels } = GenerateLogLevelMap();

export function loglevel(ll: string): loglevels {
  return logLevelByString[ll?.toLowerCase()];
}

export function shouldLogErrors(level: loglevels): boolean {
  return level >= loglevels.error;
}

export function isInfo(level: loglevels): boolean {
  return level >= loglevels.info;
}

export function isDebug(level: loglevels): boolean {
  return level >= loglevels.debug;
}

export function isWarn(level: loglevels): boolean {
  return level >= loglevels.warn;
}

export function isVerbose(level: loglevels): boolean {
  return level >= loglevels.verbose;
}

export function isSilly(level: loglevels): boolean {
  return level >= loglevels.silly;
}

let pid: string | undefined;

function checkPid(): void {
  if (!pid) {
    if (process && process.pid) {
      pid = ` [${process.pid}]`;
    } else {
      pid = '';
    }
  }
}

function TsT(): string {
  return new Date().toISOString();
  
  // 2020-08-25T18:41:37.119Z
  // return new Date().toISOString()
  //                  .substr(11);
}

function changeLoggingArgs(type: 'ERROR' | 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'SILLY', data: any[]): any[] {
  checkPid();
  if (typeof data[0] === 'string') {
    data[0] = `[${TsT()}]${pid} [${type}] ${data[0]}`;
  } else {
    data = [`[${TsT()}]${pid} [${type}]`, ...data];
  }
  return data;
}

export let logError: any;
export let logDebug: any;
export let logInfo: any;
export let logWarn: any;
export let logVerbose: any;
export let logSilly: any;

function useConsole(args: any[] | string, output: (...data: any[]) => void): void {
  if (Array.isArray(args)) {
    output(...args);
  } else {
    output(args);
  }
}

export function useConsoleLoggingWithAdvanced(): void {
  logError = (...data: any[]) => useConsole(changeLoggingArgs('ERROR', data), console.error);
  logDebug = (...data: any[]) => useConsole(changeLoggingArgs('DEBUG', data), console.debug);
  logInfo = (...data: any[]) => useConsole(changeLoggingArgs('INFO', data), console.info);
  logWarn = (...data: any[]) => useConsole(changeLoggingArgs('WARN', data), console.warn);
  logVerbose = (...data: any[]) => useConsole(changeLoggingArgs('TRACE', data), console.debug);
  logSilly = (...data: any[]) => useConsole(changeLoggingArgs('SILLY', data), console.trace);
}

export function useConsoleLogging(): void {
  logError = (...data: any[]) => useConsole(data, console.error);
  logDebug = (...data: any[]) => useConsole(data, console.debug);
  logInfo = (...data: any[]) => useConsole(data, console.info);
  logWarn = (...data: any[]) => useConsole(data, console.warn);
  logVerbose = (...data: any[]) => useConsole(data, console.debug);
  logSilly = (...data: any[]) => useConsole(data, console.trace);
}

useConsoleLoggingWithAdvanced();

export function setLoggers(infoLogger: any, debugLogger: any, warnLogger: any, errorLogger: any, verboseLogger: any, sillyLogger: any): void {
  if (infoLogger) {
    logInfo = infoLogger;
  }
  
  if (debugLogger) {
    logDebug = debugLogger;
  }
  
  if (warnLogger) {
    logWarn = warnLogger;
  }
  
  if (errorLogger) {
    logError = errorLogger;
  }
  
  if (verboseLogger) {
    logVerbose = verboseLogger;
  }
  
  if (sillyLogger) {
    logSilly = sillyLogger;
  }
}