每個App都需要一個Logger

import * as Sentry from "@sentry/nextjs";
import format from "date-fns/format";

export enum LogLevel {
  Debug = 'debug',
  Info = 'info',
  Log = 'log',
  Warn = 'warn',
  Error = 'error',
}

type Metadata = {
  /**
   * 用到Sentry breadcrumb types， 預設是  `default`. 詳情可以到下面鏈接：
   * @see https://develop.sentry.dev/sdk/event-payloads/breadcrumbs/#breadcrumb-types
   */
  type?:
    | "default"
    | "debug"
    | "error"
    | "navigation"
    | "http"
    | "info"
    | "query"
    | "transaction"
    | "ui"
    | "user",
 
  /**
   * tags會放到Sentry.captureException的函數裡面，詳情可以看下面鏈接
   *
   * @see https://github.com/getsentry/sentry-javascript/blob/903addf9a1a1534a6cb2ba3143654b918a86f6dd/packages/types/src/misc.ts#L65
   */
  tags?: {
    [key: string]:
      | number
      | string
      | boolean
      | bigint
      | symbol
      | null
      | undefined,
  },
 
  /**
   * 任何其它額外的數據都可以通過 extra 這個參數放在Sentry.captureException的函數裡面，在之後debug時使用。
   */
  [key: string]: unknown,
} & Parameters<typeof Sentry.captureException>[1];

type Transport = (
  level: LogLevel,
  message: string | Error,
  metadata: Metadata,
  timestamp: number
) => void;

export const consoleTransport: Transport = (
  level,
  message,
  metadata,
  timestamp
) => {
  const extra = Object.keys(metadata).length
    ? " " + JSON.stringify(metadata, null, "  ")
    : "";
 
  const log = {
    [LogLevel.Debug]: console.debug,
    [LogLevel.Info]: console.info,
    [LogLevel.Log]: console.log,
    [LogLevel.Warn]: console.warn,
    [LogLevel.Error]: console.error,
  }[level];
 
  log(`${format(timestamp, "HH:mm:ss")} ${message.toString()}${extra}`);
};

export const sentryTransport: Transport = (
  level,
  message,
  { type, tags, ...metadata },
  timestamp,
) => {
  if (typeof message === 'string') {
    const severity = (
      {
        [LogLevel.Debug]: 'debug',
        [LogLevel.Info]: 'info',
        [LogLevel.Log]: 'log',
        [LogLevel.Warn]: 'warning',
        [LogLevel.Error]: 'error',
      } as const
    )[level];
 
    Sentry.addBreadcrumb({
      message,
      data: metadata,
      type: type || 'default',
      level: severity,
      timestamp: timestamp / 1000, // Sentry expects seconds
    });
 
    if (level === 'error' || level === 'warn' || level === 'log') {
      const messageLevel = ({
        [LogLevel.Log]: 'log',
        [LogLevel.Warn]: 'warning',
        [LogLevel.Error]: 'error',
      }[level] || 'log') as Sentry.Breadcrumb['level'];
 
      Sentry.captureMessage(message, {
        level: messageLevel,
        tags,
        extra: metadata,
      });
    }
  } else {
    /**
     * It's otherwise an Error and should be reported with captureException
     */
    Sentry.captureException(message, {
      tags,
      extra: metadata,
    });
  }
};

/**
 * 當在APP的其它地方，注意不要直接從這個文件引入，而是用`logger.DebugContext`
 */
export const DebugContext = {
  // e.g. composer: 'composer'
  session: 'session',
  notifications: 'notifications',
} as const

export class Logger {
  LogLevel = LogLevel;
  DebugContext = DebugContext;
  enabled: boolean;
  level: LogLevel;
  transports: Transport[] = [];
 
  protected debugContextRegexes: RegExp[] = [];
 
  constructor({
    enabled = process.env.NODE_ENV !== 'test',
    level = process.env.NEXT_PUBLIC_LOG_LEVEL as LogLevel,
    debug = '',
  }: {
    enabled?: boolean;
    level?: LogLevel;
    debug?: string;
  } = {}) {
    this.enabled = enabled !== false;
    this.level = debug ? LogLevel.Debug : level ?? LogLevel.Info; //default to info
 
    this.debugContextRegexes = (debug || '').split(',').map(context => {
      return new RegExp(context.replace(/[^\w:*]/, '').replace(/\*/g, '.*'));
    });
  }
 
  debug(message: string, metadata: Metadata = {}, context?: string) {
    if (context && !this.debugContextRegexes.find(reg => reg.test(context))) {
      return;
    }
    this.transport(LogLevel.Debug, message, metadata);
  }
 
  info(message: string, metadata: Metadata = {}) {
    this.transport(LogLevel.Info, message, metadata);
  }
  log(message: string, metadata: Metadata = {}) {
    this.transport(LogLevel.Log, message, metadata);
  }
  warn(message: string, metadata: Metadata = {}) {
    this.transport(LogLevel.Warn, message, metadata);
  }
  error(error: string | Error, metadata: Metadata = {}) {
    this.transport(LogLevel.Error, error, metadata);
  }
 
  addTransport(transport: Transport) {
    this.transports.push(transport);
    return () => {
      this.transports.splice(this.transports.indexOf(transport));
    };
  }
 
  disable() {
    this.enabled = false;
  }
 
  enable() {
    this.enabled = true;
  }
 
  protected transport(
    level: LogLevel,
    message: string | Error,
    metadata: Metadata = {},
  ) {
    if (!this.enabled) {
      return;
    }
    if (!enabledLogLevels[this.level].includes(level)) {
      return;
    }
 
    const timestamp = Date.now();
    const meta = metadata || {};
    for (const transport of this.transports) {
      transport(level, message, meta, timestamp);
    }
 
    add({
      id: nanoid(),
      timestamp,
      level,
      message,
      metadata: meta,
    });
  }
}
 
export const logger = new Logger()

if (env.IS_DEV && !env.IS_TEST) {
  logger.addTransport(consoleTransport);
} else if (env.IS_PROD) {
  logger.addTransport(sentryTransport);
}