standard-log 7.0.2 → 8.0.0

package/ts/logLevelFn.ts

@@ -0,0 +1,72 @@
+import { reduceKey } from 'type-plus'
+import { getCustomLevel, getCustomLevelName, getCustomLevels } from './customLogLevel.js'
+import { getLoggers } from './getLoggers.js'
+import { logLevels } from './logLevel.js'
+import { store } from './store.js'
+import { Logger } from './types.js'
+
+/**
+ * Gets the overall log level.
+ */
+export function getLogLevel() {
+  return store.value.logLevel
+}
+
+/**
+ * Sets the overall log level.
+ * If the logger has its own local log level,
+ * that will take precedent.
+ */
+export function setLogLevel(level: number) {
+  store.value.logLevel = level
+}
+
+/**
+ * Sets log levels on specific loggers.
+ * This will override the local log level of the loggers.
+ */
+export function setLogLevels(filter: RegExp, level: number): Logger<any>[] {
+  return getLoggers(filter).map(log => {
+    log.level = level
+    return log
+  })
+}
+
+export function toLogLevel(name: string): number | undefined {
+  return getCustomLevel(name) || (logLevels as any)[name.toLowerCase()]
+}
+
+export function toLogLevelName(level: number) {
+  const custom = getCustomLevelName(level)
+  if (custom) return custom
+  switch (true) {
+    case (level <= 100):
+      return 'emergency'
+    case (level <= 200):
+      return 'alert'
+    case (level <= 300):
+      return 'critical'
+    case (level <= 400):
+      return 'error'
+    case (level <= 500):
+      return 'warn'
+    case (level <= 600):
+      return 'notice'
+    case (level <= 700):
+      return 'info'
+    case (level <= 800):
+      return 'debug'
+    case (level <= 900):
+      return 'trace'
+    default:
+      return 'planck'
+  }
+}
+
+export function getAllLogLevels() {
+  return reduceKey(logLevels, (result, name) => {
+    if (name !== 'none' && name !== 'all') result.push({ name, level: logLevels[name] })
+
+    return result
+  }, getCustomLevels())
+}

package/ts/logReporter.ts

@@ -0,0 +1,26 @@
+import { addLogReporterInternal } from './logReporterInternal.js'
+import { store } from './store.js'
+import { LogReporter } from './types.js'
+import { assertLogModeIsNotProduction } from './utils.js'
+
+export function addLogReporter(reporter: LogReporter) {
+  assertLogModeIsNotProduction('addLogReporter')
+  addLogReporterInternal(reporter)
+}
+
+export function getLogReporter(id: string) {
+  return store.value.reporters.find(r => r.id === id)
+}
+
+export function hasConsoleReporter() {
+  return store.value.reporters.some(r => r.isConsoleReporter)
+}
+
+export function getConsoleReporter() {
+  return store.value.reporters.find(r => r.isConsoleReporter)
+}
+
+export function clearLogReporters() {
+  assertLogModeIsNotProduction('clearLogReporters')
+  store.value.reporters.splice(0, store.value.reporters.length)
+}

package/ts/logReporterInternal.ts

@@ -0,0 +1,18 @@
+import { getConsoleReporter } from './logReporter.js'
+import { store } from './store.js'
+import { LogReporter } from './types.js'
+
+export function addLogReporterInternal(reporter: LogReporter) {
+  if (reporter.isConsoleReporter) {
+    const r = getConsoleReporter()
+    if (r && reporter.filter) {
+      const f = r.filter
+      const f2 = reporter.filter
+      if (f) r.filter = entry => f(entry) && f2(entry)
+      else r.filter = f2
+    }
+  }
+  else {
+    store.value.reporters.push(reporter)
+  }
+}

package/ts/memory/MemoryLogReporter.ts

@@ -0,0 +1,66 @@
+import { required } from 'type-plus'
+import { formatLogLevel } from '../formatter/index.js'
+import { LogEntry, LogFilter, LogFormatter, LogReporter, LogReporterOptions } from '../types.js'
+import { assertLogModeIsNotProduction } from '../utils.js'
+import { toInspectLogEntry } from './toInspectStringForObject.js'
+
+export type MemoryLogReporter = LogReporter<LogEntry> & {
+  logs: LogEntry[],
+  /**
+   * Gets a simple log message for testing.
+   * The message only contains arguments for each log entry.
+   */
+  getLogMessage(): string,
+  getLogMessageWithLevel(): string
+}
+
+export type MemoryLogFormatter = LogFormatter<LogEntry>
+
+function createGetLogMessage() {
+  return function getLogMessage(this: { logs: LogEntry[] }) {
+    return this.logs.map(toInspectLogEntry)
+      .map(log => log.args.join(' '))
+      .join('\n')
+  }
+}
+
+export function toMessageWithLevel(logs: LogEntry[]) {
+  return logs.map(toInspectLogEntry)
+    .map(log => `${formatLogLevel(log.level)} ${log.args.join(' ')}`)
+    .join('\n')
+    // if it has more than this log,
+    // we assume it is running under tests,
+    // and remove this log to simplify testing.
+    .replace(/^\(WARN\) already configured for test, ignoring config\(\) call\n/, '')
+}
+
+
+export function createMemoryLogReporter(options?: LogReporterOptions<LogEntry>): MemoryLogReporter {
+  const opt = required({ id: 'memory', formatter: (e: LogEntry) => e }, options)
+  const { id } = opt
+  let { formatter, filter } = opt
+  return {
+    id,
+    get formatter() {
+      return formatter
+    },
+    set formatter(value: MemoryLogFormatter) {
+      assertLogModeIsNotProduction('set Reporter.formatter')
+      formatter = value
+    },
+    get filter() {
+      return filter
+    },
+    set filter(value: LogFilter) {
+      assertLogModeIsNotProduction('set Reporter.filter')
+      filter = value
+    },
+    logs: [],
+    write(entry) {
+      if (filter && !filter(entry)) return
+      this.logs.push(formatter(entry))
+    },
+    getLogMessage: createGetLogMessage(),
+    getLogMessageWithLevel() { return toMessageWithLevel(this.logs) }
+  }
+}

package/ts/memory/index.ts

@@ -0,0 +1,2 @@
+export * from './logEntriesToString.js'
+export * from './MemoryLogReporter.js'

package/ts/memory/logEntriesToString.ts

@@ -0,0 +1,7 @@
+import { plainLogFormatter } from '../formatter/index.js'
+import { LogEntry } from '../types.js'
+import { toInspectLogEntry } from './toInspectStringForObject.js'
+
+export function logEntriesToString(logs: LogEntry[]) {
+  return logs.map(toInspectLogEntry).map(plainLogFormatter).join('\n')
+}

package/ts/memory/toInspectStringForObject.ts

@@ -0,0 +1,13 @@
+import isNode from 'is-node'
+import { LogEntry } from '../LogEntry.js'
+
+export const toInspectLogEntry = isNode
+  ? (() => {
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const inspect = require('util').inspect
+    return (e: LogEntry) => (
+      e.args = e.args.map(value => typeof value === 'object' && value !== null ? inspect(value) : value),
+      e)
+  })()
+  // istanbul ignore next
+  : (e: LogEntry) => e

package/ts/shouldLog.ts

@@ -0,0 +1,11 @@
+import { store } from './store.js'
+import { LogLevel } from './types.js'
+
+/**
+ * Determines should you log.
+ * @param loggerLevel Log level of the logger.
+ * It can be undefined which the global log level will be used.
+ */
+export function shouldLog(targetLevel: LogLevel, loggerLevel: LogLevel | undefined) {
+  return targetLevel <= (loggerLevel !== undefined ? loggerLevel : store.value.logLevel)
+}

package/ts/store.ts

@@ -0,0 +1,25 @@
+import { createStore } from 'global-store'
+import { getLogModeFromEnvironment } from './getLogModeFromEnvironment.js'
+import { logLevels } from './logLevel.js'
+import { LogStore } from './typesInternal.js'
+
+export const store = createStore<LogStore>({
+  moduleName: 'standard-log',
+  key: 'e53d0937-f420-40a0-9901-099725fa4a53',
+  version: '2.0.0',
+  initializer: (current) => {
+    const mode = getLogModeFromEnvironment() || 'production'
+    return {
+      addCustomLogLevelListeners: [],
+      configured: false,
+      loggerClosures: {},
+      redirects: {},
+      reporters: [],
+      customLevels: {},
+      customLevelsReverse: [],
+      mode,
+      logLevel: logLevels.info,
+      ...current
+    }
+  }
+})

package/ts/suppressLogs.ts

@@ -0,0 +1,14 @@
+import { logLevels } from './logLevel.js'
+import { Logger } from './types.js'
+
+/**
+ * Suppress logging within the code block.
+ */
+export function suppressLogs<R>(block: () => R, log: Logger, ...logs: Logger[]): R
+export function suppressLogs<R>(block: () => R, ...logs: Logger[]): R {
+  const origLevels = logs.map(l => l.level)
+  logs.forEach(l => l.level = logLevels.none)
+  const result = block()
+  logs.forEach((l, i) => l.level = origLevels[i])
+  return result
+}

package/ts/testUtil.ts

@@ -0,0 +1,19 @@
+import R from 'ramda'
+import { LogEntry } from './types.js'
+import { writeToReporters } from './writeToReporters.js'
+
+export function rangeEntries(start: number, end: number, expected: any) {
+  return R.range(start, end).map(value => ([value, expected]))
+}
+
+export function captureWrittenLog() {
+  const logs: LogEntry[] = []
+  const orig = writeToReporters.fn
+  writeToReporters.fn = l => logs.push(l)
+  return {
+    logs,
+    reset() {
+      writeToReporters.fn = orig
+    }
+  }
+}

package/ts/typesInternal.ts

@@ -0,0 +1,21 @@
+import { Logger, LogLevel, LogLevelListener, LogMode, LogReporter } from './types.js'
+
+export type LoggerClosure<T extends string> = {
+  addMethod(name: string, level: number): void,
+  logger: Logger<T>
+}
+
+export type LogStore = {
+  mode: LogMode,
+  logLevel: LogLevel,
+  loggerClosures: Record<string, LoggerClosure<any>>,
+  /**
+   * redirects logger to specific reporter.
+   */
+  redirects: Record<string, LogReporter[]>,
+  reporters: LogReporter[],
+  customLevels: Record<string, number>,
+  customLevelsReverse: string[],
+  addCustomLogLevelListeners: LogLevelListener[],
+  configured: boolean
+}

package/ts/utils.ts

@@ -0,0 +1,9 @@
+import { ProhibitedDuringProduction } from './errors.js'
+import { store } from './store.js'
+
+/**
+ * Helper function to assert the system is not in production mode.
+ */
+export function assertLogModeIsNotProduction(action: string) {
+  if (store.value.mode === 'production') throw new ProhibitedDuringProduction(action)
+}

package/ts/writeToReporters.ts

@@ -0,0 +1,20 @@
+import { config } from './config.js'
+import { store } from './store.js'
+import { LogEntry } from './types.js'
+
+export function writeToReporters(logEntry: LogEntry, filter: (reporterId: string) => boolean) {
+  writeToReporters.fn(logEntry, filter)
+}
+
+// istanbul ignore next
+writeToReporters.fn = (logEntry: LogEntry, filter: (reporterId: string) => boolean) => {
+  const store = getConfiguredStore()
+  const redirect = store.value.redirects[logEntry.id]
+  const reporters = redirect && redirect.length > 0 ? redirect : store.value.reporters
+  reporters.filter(r => filter(r.id)).forEach(r => r.write(logEntry!))
+}
+
+function getConfiguredStore() {
+  if (!store.value.configured) config()
+  return store
+}