@vrplatform/log 1.0.0

package/src/baselog.ts

@@ -0,0 +1,170 @@
+import { getCorrelationId, requestToContext } from './common';
+import type { BaseLog, ChildLogOptions, Log } from './type';
+export * from './type';
+import { Axiom } from '@axiomhq/js';
+import { serializeError } from 'serialize-error';
+import { logger } from './color';
+
+let lastMessageTimestamp: number | undefined = undefined;
+
+export function createBaseLog(
+  {
+    token,
+    orgId = 'vrplatform-mv6k',
+    dataset,
+    consoleLog,
+  }: {
+    token?: string;
+    orgId?: string;
+    dataset?: string;
+    consoleLog?: boolean | 'color';
+  },
+  {
+    environment,
+    workerId,
+    app,
+    version,
+    context,
+    type,
+    correlationId,
+    executionContext,
+  }: {
+    correlationId?: string;
+    environment?: 'development' | 'production';
+    type?: 'worker' | 'durableObject';
+    workerId?: string;
+    app?: string;
+    version?: string;
+    context?: Record<string, any>;
+    executionContext?: {
+      waitUntil(promise: Promise<any>): void;
+    };
+  }
+): BaseLog {
+  const baseFields: Record<string, any> = {
+    type: type || 'worker',
+    environment: environment || 'production',
+    worker: {
+      id: workerId || 'default',
+      app: app || 'default',
+      version: version || 'default',
+      started: new Date().toISOString(),
+    },
+    ...context,
+  };
+
+  const axiom = token
+    ? new Axiom({
+        token,
+        orgId,
+        onError() {},
+      })
+    : undefined;
+
+  function ingest(
+    level: 'info' | 'log' | 'error' | 'debug' | string,
+    message: string,
+    additionalFields: Record<string, any> = {}
+  ) {
+    axiom?.ingest(dataset!, {
+      _time: Date.now(),
+      level,
+      message,
+      ...baseFields,
+      ...additionalFields,
+    });
+  }
+
+  function createBaseLog(arg: ChildLogOptions = {}): Log {
+    const childContext = arg.context || {};
+    if (arg.request) {
+      childContext.request = requestToContext(arg.request);
+    }
+    const baseLog = (
+      level: string,
+      message: any,
+      additionalContext: Record<string, any> = {}
+    ) => {
+      const cid =
+        arg.correlationId ||
+        correlationId ||
+        childContext?.correlationId ||
+        additionalContext?.correlationId ||
+        correlationId;
+      ingest(level, message, {
+        ...childContext,
+        ...additionalContext,
+        correlationId: cid,
+      });
+      if (consoleLog) {
+        const name = arg.name ? `${app}/${arg.name}` : app;
+        const lev = level.toUpperCase();
+
+        const now = Date.now();
+        const diff = (
+          lastMessageTimestamp ? `${now - lastMessageTimestamp}ms ` : ''
+        ).padEnd(6, ' ');
+        lastMessageTimestamp = now;
+        if (consoleLog === 'color')
+          logger
+            .dim()
+            .append(`${diff}`)
+            .reset()
+            .color('green')
+            .append(`[${name}] `)
+            .reset()
+            .bold()
+            .append(`${lev} `)
+            .reset()
+            .color('blue')
+            .bold()
+            .append(cid ? `[${cid}] ` : '')
+            .reset()
+            .append(message)
+            .log();
+        else
+          console.log(`[${lev}] [${name}]${cid ? ` [${cid}]` : ''} ${message}`);
+      }
+    };
+    return {
+      addContext(arg) {
+        for (const key in arg) {
+          childContext[key] = arg[key];
+        }
+      },
+      child: ({
+        correlationId,
+        name,
+        request,
+        context = {},
+      }: ChildLogOptions) =>
+        createBaseLog({
+          correlationId:
+            correlationId ||
+            (request ? getCorrelationId(request) : undefined) ||
+            undefined,
+          name,
+          request,
+          context: { ...childContext, ...context },
+        }),
+      error: (message, error) => {
+        const m =
+          typeof message === 'string'
+            ? message
+            : error?.message || error?.name || 'Error';
+        const e = typeof message === 'string' ? error : message;
+        return baseLog('error', m, e instanceof Error ? serializeError(e) : e);
+      },
+      debug: (message, data) => baseLog('debug', message, data),
+      warn: (message, data) => baseLog('warn', message, data),
+      info: (message, data) => baseLog('info', message, data),
+    };
+  }
+  const baseLog = createBaseLog() as any as BaseLog;
+  baseLog.flush = () => {
+    if (executionContext && axiom) {
+      executionContext.waitUntil(axiom.flush());
+    } else if (axiom) return axiom.flush();
+  };
+  return baseLog;
+}

package/src/color.ts

@@ -0,0 +1,456 @@
+export const objectEntries = Object.entries as <T extends object>(
+  value: T
+) => {
+  [K in keyof T]-?: [K, T[K]];
+}[keyof T][];
+
+export type LEVEL = 'debug' | 'info' | 'warn' | 'error' | 'disable' | 'success';
+
+type ticketObject = {
+  font?: COLOR;
+  bg?: COLOR;
+};
+
+type settingObject = {
+  [key in SETTING]?: boolean;
+};
+
+export type SETTING =
+  | 'bold'
+  | 'italic'
+  | 'dim'
+  | 'underscore'
+  | 'reverse'
+  | 'strikethrough';
+
+export type COLOR =
+  | 'black'
+  | 'red'
+  | 'green'
+  | 'yellow'
+  | 'blue'
+  | 'magenta'
+  | 'cyan'
+  | 'white';
+
+const CONFIG = {
+  SYSTEM: {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    italic: '\x1b[3m',
+    underscore: '\x1b[4m',
+    reverse: '\x1b[7m',
+    strikethrough: '\x1b[9m',
+    backoneline: '\x1b[1A',
+    cleanthisline: '\x1b[K',
+  },
+  FONT: {
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+  },
+  BACKGROUND: {
+    black: '\x1b[40m',
+    red: '\x1b[41m',
+    green: '\x1b[42m',
+    yellow: '\x1b[43m',
+    blue: '\x1b[44m',
+    magenta: '\x1b[45m',
+    cyan: '\x1b[46m',
+    white: '\x1b[47m',
+  },
+};
+
+// Sequence of levels is important.
+const LEVELS = ['success', 'debug', 'info', 'warn', 'error', 'disable'];
+
+class Logger {
+  private command: string;
+  private lastCommand: string;
+  private name: string;
+  private level?: LEVEL;
+  private noColor: boolean;
+  private _getDate: () => string;
+  private _customizedConsole: Console;
+  constructor(name?: string) {
+    // Current command
+    this.command = '';
+    // Last line
+    this.lastCommand = '';
+
+    this.name = name || '';
+
+    // set level from env
+    const level =
+      typeof process !== 'undefined' ? process.env.LOGGER : undefined;
+    if (this.isLevelValid(level)) {
+      this.level = level as LEVEL;
+    }
+
+    this.noColor = false;
+
+    this._getDate = () => new Date().toISOString();
+
+    this._customizedConsole = console;
+  }
+
+  createNamedLogger(name: string) {
+    return new Logger(name);
+  }
+
+  setLevel(level: LEVEL) {
+    if (this.isLevelValid(level)) {
+      this.level = level;
+    } else {
+      throw 'Level you are trying to set is invalid';
+    }
+  }
+
+  setLogStream(newStream: any) {
+    if (newStream.writable) {
+      this._customizedConsole = new console.Console(newStream);
+    } else {
+      throw 'invalid writable stream object';
+    }
+  }
+
+  setLevelNoColor() {
+    this.noColor = true;
+  }
+
+  setLevelColor() {
+    this.noColor = false;
+  }
+
+  isLevelValid(level?: string) {
+    return LEVELS.includes(level!);
+  }
+
+  isAllowedLevel(level: LEVEL) {
+    return this.level
+      ? LEVELS.indexOf(this.level) <= LEVELS.indexOf(level)
+      : true;
+  }
+
+  log(...args: any[]) {
+    this.append(...args);
+    if (!this.noColor) {
+      this.command += CONFIG.SYSTEM.reset;
+    }
+    this._print(this.command);
+    // Save last command if we need to use for joint
+    this.lastCommand = this.command;
+    this.command = '';
+    return this;
+  }
+
+  // deprecated
+  joint() {
+    console.error(
+      'node-color-log warning: `joint` is deprecated, please use `append`'
+    );
+
+    // Clear the last line
+    this._print(CONFIG.SYSTEM.backoneline + CONFIG.SYSTEM.cleanthisline);
+
+    // Reset the command to let it joint the next
+    // And print from the position of last line
+    this.command = '';
+
+    // if joint more than twice, we should clean the previous
+    // backline command, since we should only do it for the
+    // current time.
+    this.lastCommand = this.lastCommand.replace(CONFIG.SYSTEM.backoneline, '');
+
+    // back to the last line
+    this.command += CONFIG.SYSTEM.backoneline;
+
+    this.command += this.lastCommand;
+    return this;
+  }
+
+  setDate(callback: () => string) {
+    this._getDate = callback;
+  }
+
+  getPrefix() {
+    if (this.name) {
+      return `${this._getDate()} [${this.name}]`;
+    } else {
+      return this._getDate();
+    }
+  }
+
+  color(ticket: COLOR) {
+    if (ticket in CONFIG.FONT) {
+      this.command += CONFIG.FONT[ticket];
+    } else {
+      console.error(
+        'node-color-log warning: Font color not found! Use the default.'
+      );
+    }
+    return this;
+  }
+
+  bgColor(ticket: COLOR) {
+    if (ticket in CONFIG.BACKGROUND) {
+      this.command += CONFIG.BACKGROUND[ticket];
+    } else {
+      console.error(
+        'node-color-log warning: Background color not found! Use the default.'
+      );
+    }
+    return this;
+  }
+
+  bold() {
+    this.command += CONFIG.SYSTEM.bold;
+    return this;
+  }
+
+  dim() {
+    this.command += CONFIG.SYSTEM.dim;
+    return this;
+  }
+
+  underscore() {
+    this.command += CONFIG.SYSTEM.underscore;
+    return this;
+  }
+
+  strikethrough() {
+    this.command += CONFIG.SYSTEM.strikethrough;
+    return this;
+  }
+
+  reverse() {
+    this.command += CONFIG.SYSTEM.reverse;
+    return this;
+  }
+
+  italic() {
+    this.command += CONFIG.SYSTEM.italic;
+    return this;
+  }
+
+  fontColorLog(ticket: COLOR, text: string, setting?: settingObject) {
+    let command = '';
+    if (setting) {
+      command += this.checkSetting(setting);
+    }
+    if (ticket in CONFIG.FONT) {
+      command += CONFIG.FONT[ticket];
+    } else {
+      console.error(
+        'node-color-log warning: Font color not found! Use the default.'
+      );
+    }
+    command += text;
+
+    command += CONFIG.SYSTEM.reset;
+    this._print(command);
+  }
+
+  bgColorLog(ticket: COLOR, text: string, setting?: settingObject) {
+    let command = '';
+    if (setting) {
+      command += this.checkSetting(setting);
+    }
+    if (ticket in CONFIG.BACKGROUND) {
+      command += CONFIG.BACKGROUND[ticket];
+    } else {
+      console.error(
+        'node-color-log warning: Background color not found! Use the default.'
+      );
+    }
+    command += text;
+
+    command += CONFIG.SYSTEM.reset;
+    this._print(command);
+  }
+
+  colorLog(ticketObj: ticketObject, text: string, setting?: settingObject) {
+    let command = '';
+    if (setting) {
+      command += this.checkSetting(setting);
+    }
+    if (ticketObj.font! in CONFIG.FONT) {
+      command += CONFIG.FONT[ticketObj.font!];
+    } else {
+      console.error(
+        'node-color-log warning: Font color not found! Use the default.'
+      );
+    }
+    if (ticketObj.bg! in CONFIG.BACKGROUND) {
+      command += CONFIG.BACKGROUND[ticketObj.bg!];
+    } else {
+      console.error(
+        'node-color-log warning: Background color not found! Use the default.'
+      );
+    }
+
+    command += text;
+
+    command += CONFIG.SYSTEM.reset;
+    this._print(command);
+  }
+
+  error(...args: any[]) {
+    if (!this.isAllowedLevel('error')) return;
+
+    if (this.noColor) {
+      const d = this.getPrefix();
+      this.log(d, ' [ERROR] ', ...args);
+    } else {
+      const d = this.getPrefix();
+      this.append(`${d} `)
+        .bgColor('red')
+        .append('[ERROR]')
+        .reset()
+        .append(' ')
+        .color('red')
+        .log(...args);
+    }
+  }
+
+  warn(...args: any[]) {
+    if (!this.isAllowedLevel('warn')) return;
+
+    if (this.noColor) {
+      const d = this.getPrefix();
+      this.log(d, ' [WARN] ', ...args);
+    } else {
+      const d = this.getPrefix();
+      this.append(`${d} `)
+        .bgColor('yellow')
+        .color('black')
+        .append('[WARN]')
+        .reset()
+        .append(' ')
+        .color('yellow')
+        .log(...args);
+    }
+  }
+
+  info(...args: any[]) {
+    if (!this.isAllowedLevel('info')) return;
+
+    if (this.noColor) {
+      const d = this.getPrefix();
+      this.log(d, ' [INFO] ', ...args);
+    } else {
+      const d = this.getPrefix();
+      this.append(`${d} `)
+        .bgColor('green')
+        .color('black')
+        .append('[INFO]')
+        .reset()
+        .append(' ')
+        .color('green')
+        .log(...args);
+    }
+  }
+
+  debug(...args: any[]) {
+    if (!this.isAllowedLevel('debug')) return;
+
+    if (this.noColor) {
+      const d = this.getPrefix();
+      this.log(d, ' [DEBUG] ', ...args);
+    } else {
+      const d = this.getPrefix();
+      this.append(`${d} `)
+        .bgColor('cyan')
+        .color('black')
+        .append('[DEBUG]')
+        .reset()
+        .append(' ')
+        .color('cyan')
+        .log(...args);
+    }
+  }
+
+  success(...args: any[]) {
+    if (!this.isAllowedLevel('success')) return;
+
+    if (this.noColor) {
+      const d = this.getPrefix();
+      this.log(d, ' [SUCCESS] ', ...args);
+    } else {
+      const d = this.getPrefix();
+      this.append(`${d} `)
+        .bgColor('green')
+        .color('black')
+        .append('[SUCCESS]')
+        .reset()
+        .append(' ')
+        .color('green')
+        .log(...args);
+    }
+  }
+
+  checkSetting(setting: settingObject) {
+    const validSetting = [
+      'bold',
+      'italic',
+      'dim',
+      'underscore',
+      'reverse',
+      'strikethrough',
+    ];
+    let command = '';
+    for (const [k, s] of objectEntries(setting)) {
+      if (validSetting.indexOf(k) !== -1) {
+        if (s === true) {
+          command += CONFIG.SYSTEM[k];
+        } else if (s !== false) {
+          console.error(
+            `node-color-log warning: The value ${k} should be boolean.`
+          );
+        }
+      } else {
+        console.error(`node-color-log warning: ${k} is not valid in setting.`);
+      }
+    }
+    return command;
+  }
+
+  // helper function to output the the log to stream
+  _print(...args: any[]) {
+    this._customizedConsole.log(...args);
+  }
+
+  // helper function to append the command buffer
+  append(...args: any[]) {
+    for (let idx = 0; idx < args.length; idx++) {
+      const arg = args[idx];
+      if (typeof arg === 'string') {
+        this.command += arg;
+      } else {
+        try {
+          this.command += JSON.stringify(arg);
+        } catch {
+          this.command += arg;
+        }
+      }
+
+      if (args.length > 1 && idx < args.length - 1) {
+        this.command += ' ';
+      }
+    }
+    return this;
+  }
+
+  reset() {
+    this.command += CONFIG.SYSTEM.reset;
+    return this;
+  }
+}
+
+export const logger = new Logger();

package/src/common.ts

@@ -0,0 +1,84 @@
+import type { RequestLike } from './type';
+
+// Headers
+export const CONNECTION_ID_HEADER = 'X-Connection-ID';
+export const WORKFLOW_ID_HEADER = 'X-Workflow-ID';
+export const TASK_QUEUE_HEADER = 'X-Task-Queue';
+export const CORRELATION_ID_HEADER = 'X-Correlation-ID';
+export const VERIFICATION_HEADER = 'X-Verification-Key';
+
+// Env
+export const AXIOM_AUTH_TOKEN_ENV = 'AXIOM_AUTH_TOKEN';
+export const AXIOM_ORG_ID_ENV = 'AXIOM_ORG_ID';
+export const AXIOM_DATASET_ENV = 'AXIOM_DATASET';
+export const LOG_ENV = 'LOG';
+
+export const requestHeadersToCapture = ['user-agent'];
+
+export function getCorrelationId(request?: RequestLike) {
+  if (!request?.headers) return undefined;
+  return (
+    request.headers.get(CORRELATION_ID_HEADER) ||
+    request.headers.get('fi-correlation-id') ||
+    request.headers.get('x-correlation-id') ||
+    request.headers.get('correlation-id') ||
+    request.headers.get('x-transaction-id') ||
+    request.headers.get('transaction-id') ||
+    request.headers.get('cf-ray') ||
+    request.headers.get('cf-request-id') ||
+    request.headers.get('request-id') ||
+    undefined
+  );
+}
+
+export function isDev(request?: RequestLike) {
+  return request?.url?.startsWith('http://localhost:');
+}
+
+export function mergeFn<
+  TFn extends (...args: any[]) => any,
+  TObj extends Record<string, unknown>,
+>(fn: TFn, obj: TObj): TFn & TObj {
+  return Object.assign(fn, obj);
+}
+
+export function getHeaderMap(
+  headers: any | undefined,
+  allowlist: string[] = []
+) {
+  if (!allowlist.length || !headers) {
+    return {};
+  }
+
+  return [...headers].reduce((acc, [headerKey, headerValue]) => {
+    if (allowlist.includes(headerKey)) {
+      acc[headerKey] = headerValue;
+    }
+
+    return acc;
+  }, {});
+}
+
+export function requestToContext(
+  request?: RequestLike & { cf?: any; body?: any },
+  body?: any
+) {
+  if (!request) return {};
+
+  const cf: Record<string, unknown> = {};
+  if (request?.cf) {
+    // delete does not work so we copy into a new object
+    for (const [key, value] of Object.entries(request.cf)) {
+      if (key !== 'tlsClientAuth' && key !== 'tlsExportedAuthenticator') {
+        cf[key] = value;
+      }
+    }
+  }
+  return {
+    url: request?.url,
+    headers: getHeaderMap(request?.headers, requestHeadersToCapture),
+    method: request?.method,
+    cloudflare: cf,
+    body: body || request.body || undefined,
+  };
+}