standard-log 7.0.3 → 8.0.1

package/src/logLevel.spec.ts

@@ -1,161 +0,0 @@
-import t from 'assert';
-import { forEachKey } from 'type-plus';
-import { addCustomLogLevel, clearCustomLogLevel, getAllLogLevels, getLogger, getLogLevel, logLevels, setLogLevel, setLogLevels, toLogLevel, toLogLevelName } from '.';
-import { store } from './store';
-import { captureWrittenLog, rangeEntries } from './testUtil';
-
-function createFilterLoggers() {
-  for (let i = 0; i < 20; i++) {
-    getLogger('filter' + i)
-    getLogger('filter-' + String.fromCharCode(97 + i))
-  }
-}
-
-beforeAll(() => {
-  createFilterLoggers()
-})
-
-afterAll(() => {
-  store.reset()
-})
-
-describe('capture write to reporters', () => {
-  let capture: ReturnType<typeof captureWrittenLog>
-  beforeEach(() => {
-    store.value.mode = 'test'
-    store.value.logLevel = logLevels.error
-    capture = captureWrittenLog()
-  })
-  afterEach(() => {
-    capture.reset()
-  })
-  test('no matched logger do no harm', async () => {
-    setLogLevels(/x/, logLevels.debug)
-    const log = getLogger('filter1')
-    log.debug('abc')
-
-    expect(capture.logs.length).toEqual(0)
-  })
-  describe('setLogLevels()', () => {
-    beforeEach(() => {
-      setLogLevel(logLevels.none)
-    })
-    test('only filtered log are affected', async () => {
-      const logs = setLogLevels(/filter1/, logLevels.debug)
-      t.deepStrictEqual(logs.map(l => l.id), [
-        'filter1',
-        'filter10',
-        'filter11',
-        'filter12',
-        'filter13',
-        'filter14',
-        'filter15',
-        'filter16',
-        'filter17',
-        'filter18',
-        'filter19'
-      ])
-
-      getLogger('filter1').debug('filter1')
-      getLogger('filter2').debug('filter2')
-      getLogger('filter11').debug('filter11')
-
-      t.strictEqual(capture.logs.length, 2)
-    })
-  })
-})
-
-describe('getLogLevel', () => {
-  test('default to debug in test mode', () => {
-    store.value.mode = 'test'
-    store.value.logLevel = logLevels.debug
-    expect(getLogLevel()).toBe(logLevels.debug)
-  })
-})
-
-describe('toLogLevelName()', () => {
-  test.each([
-    ...rangeEntries(99, 100, 'emergency'),
-    ...rangeEntries(199, 200, 'alert'),
-    ...rangeEntries(299, 300, 'critical'),
-    ...rangeEntries(399, 400, 'error'),
-    ...rangeEntries(499, 500, 'warn'),
-    ...rangeEntries(599, 600, 'notice'),
-    ...rangeEntries(699, 700, 'info'),
-    ...rangeEntries(799, 800, 'debug'),
-    ...rangeEntries(899, 900, 'trace'),
-    ...rangeEntries(9999999, 10000000, 'planck')
-  ])('convert %i to %s', (level: number, logLevel: string) => {
-    expect(toLogLevelName(level)).toBe(logLevel)
-  })
-
-  test('get custom log level name', () => {
-    addCustomLogLevel('cust-name', 144)
-    expect(toLogLevelName(144)).toBe('cust-name')
-  })
-})
-
-describe('toLogLevel()', () => {
-  afterEach(() => clearCustomLogLevel())
-  test('get default log levels', () => {
-    const actual = [
-      toLogLevel('emergency'),
-      toLogLevel('alert'),
-      toLogLevel('critical'),
-      toLogLevel('error'),
-      toLogLevel('warn'),
-      toLogLevel('notice'),
-      toLogLevel('info'),
-      toLogLevel('debug'),
-      toLogLevel('trace'),
-      toLogLevel('planck')
-    ]
-    expect(actual).toEqual([
-      100, 200, 300, 400, 500, 600, 700, 800, 900, Infinity
-    ])
-  })
-
-  test('get custom log level', () => {
-    addCustomLogLevel('cust-get', 123)
-    expect(toLogLevel('cust-get')).toBe(123)
-  })
-
-  test('case insensitive', () => {
-    const actual = [
-      toLogLevel('emerGency'),
-      toLogLevel('aleRt'),
-      toLogLevel('critIcal'),
-      toLogLevel('errOr'),
-      toLogLevel('warN'),
-      toLogLevel('nOtice'),
-      toLogLevel('iNfo'),
-      toLogLevel('deBug'),
-      toLogLevel('traCe'),
-      toLogLevel('planCk')
-    ]
-    expect(actual).toEqual([
-      100, 200, 300, 400, 500, 600, 700, 800, 900, Infinity
-    ])
-  })
-})
-
-describe('getAllLogLevels', () => {
-  test('get all default log levels except none and all', () => {
-    const actual = getAllLogLevels()
-    forEachKey(logLevels, name => {
-      if (name === 'none' || name === 'all') {
-        expect(actual.find(x => x.name === name)).toBeUndefined()
-      }
-      else {
-        expect(actual.find(x => x.name === name)).toEqual({ name, level: logLevels[name] })
-      }
-    })
-  })
-  test('include custom level (even if they have the same level value as one of the default level)', () => {
-    addCustomLogLevel('info_a', 301)
-    addCustomLogLevel('info_b', logLevels.info)
-    const actual = getAllLogLevels()
-    expect(actual.find(x => x.name === 'info_a')).toEqual({ name: 'info_a', level: 301 })
-    expect(actual.find(x => x.name === 'info_b')).toEqual({ name: 'info_b', level: logLevels.info })
-  })
-})

package/src/logLevelFn.ts

@@ -1,72 +0,0 @@
-import { reduceKey } from 'type-plus'
-import { getCustomLevel, getCustomLevelName, getCustomLevels } from './customLogLevel'
-import { getLoggers } from './getLoggers'
-import { logLevels } from './logLevel'
-import { store } from './store'
-import { Logger } from './types'
-
-/**
- * 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/src/logReporter.spec.ts

@@ -1,99 +0,0 @@
-import a from 'assertron'
-import {
-  addLogReporter, clearLogReporters, config,
-  createConsoleLogReporter, createMemoryLogReporter,
-  getConsoleReporter, getLogReporter, hasConsoleReporter,
-  LogFilter, logLevels, ProhibitedDuringProduction
-} from '.'
-import { store } from './store'
-
-describe('production checks', () => {
-  beforeEach(() => store.reset())
-
-  describe('addLogReporter()', () => {
-    test('throws in production mode', () => {
-      config({ mode: 'production' })
-      const reporter = createMemoryLogReporter()
-      a.throws(() => addLogReporter(reporter), ProhibitedDuringProduction)
-    })
-  })
-
-  describe('clearLogReporters()', () => {
-    test('throws in production mode', () => {
-      config({ mode: 'production' })
-      a.throws(() => clearLogReporters(), ProhibitedDuringProduction)
-    })
-  })
-})
-
-describe('unit tests', () => {
-  beforeEach(() => {
-    store.reset()
-    config({ mode: 'test' })
-  })
-
-  describe('addLogReporter()', () => {
-    test('adds log reporter', () => {
-      const count = store.value.reporters.length
-      const reporter = createMemoryLogReporter()
-      addLogReporter(reporter)
-
-      expect(store.value.reporters.length).toBe(count + 1)
-    })
-
-    describe('add another console reporter', () => {
-      test('will not replace existing one', () => {
-        expect(getLogReporter('console')).toBeDefined()
-        addLogReporter(createConsoleLogReporter({ id: 'c2' }))
-        expect(getLogReporter('c2')).toBeUndefined()
-        expect(getLogReporter('console')).toBeDefined()
-      })
-
-      test('will carry over existing filter', () => {
-        const filter: LogFilter = entry => entry.level < logLevels.alert
-        addLogReporter(createConsoleLogReporter({ id: 'c2', filter }))
-        addLogReporter(createConsoleLogReporter({ id: 'c3' }))
-        const c3 = getConsoleReporter()!
-        expect(c3.filter).toBe(filter)
-      })
-
-      test('will combine existing filter and new filter', () => {
-        addLogReporter(createConsoleLogReporter({ id: 'c2', filter: entry => entry.level > logLevels.critical }))
-        addLogReporter(createConsoleLogReporter({ id: 'c3', filter: entry => entry.level < logLevels.error }))
-        const c2 = getConsoleReporter()!
-        expect(c2.filter!({ level: logLevels.info } as any)).toBe(false)
-        expect(c2.filter!({ level: logLevels.alert } as any)).toBe(false)
-      })
-    })
-  })
-
-  describe('getLogReporter()', () => {
-    test('get log reporter by id', () => {
-      expect(getLogReporter('console')).toBeDefined()
-    })
-
-    test('get log reporter with unknown id gets undefined', () => {
-      expect(getLogReporter('blah')).toBeUndefined()
-    })
-  })
-
-  describe('clearLogReporters()', () => {
-    test('removes all reporters', () => {
-      clearLogReporters()
-
-      expect(store.value.reporters.length).toBe(0)
-    })
-  })
-
-  describe('hasConsoleReporter()', () => {
-    test('returns true if there is a console reporter', () => {
-      expect(hasConsoleReporter()).toBeTruthy()
-    })
-    test('returns false if there is no console reporter', () => {
-      clearLogReporters()
-      expect(hasConsoleReporter()).toBeFalsy()
-      addLogReporter(createMemoryLogReporter())
-      expect(hasConsoleReporter()).toBeFalsy()
-    })
-  })
-})

package/src/logReporter.ts

@@ -1,26 +0,0 @@
-import { addLogReporterInternal } from './logReporterInternal'
-import { store } from './store';
-import { LogReporter } from './types';
-import { assertLogModeIsNotProduction } from './utils';
-
-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/src/logReporterInternal.ts

@@ -1,18 +0,0 @@
-import { getConsoleReporter } from './logReporter'
-import { store } from './store'
-import { LogReporter } from './types'
-
-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/src/memory/MemoryLogReporter.spec.ts

@@ -1,114 +0,0 @@
-import a from 'assertron'
-import { config, createMemoryLogReporter, logLevels, ProhibitedDuringProduction } from '..'
-import { configForTest } from '../configForTest'
-import { getLogger } from '../getLogger'
-import { store } from '../store'
-
-describe('production checks', () => {
-  beforeEach(() => store.reset())
-  test('set formatter in production mode throws', () => {
-    config({ mode: 'production' })
-    const reporter = createMemoryLogReporter()
-
-    a.throws(() => { reporter.formatter = e => e }, ProhibitedDuringProduction)
-  })
-
-  test('set filter in production mode throws', () => {
-    config({ mode: 'production' })
-    const reporter = createMemoryLogReporter()
-    a.throws(() => { reporter.filter = () => true }, ProhibitedDuringProduction)
-  })
-
-  describe('getLogMessageWithLevel()', () => {
-    test('the production log is omitted', () => {
-      const { reporter } = configForTest()
-      config({ mode: 'production' })
-      getLogger('test').warn('some test warnings')
-      expect(reporter.getLogMessageWithLevel()).toEqual(`(WARN) some test warnings`)
-    })
-  })
-})
-
-describe('unit tests', () => {
-  beforeEach(() => {
-    store.reset()
-    config({ mode: 'test' })
-  })
-  test('log entries are saved in the `logs` property', () => {
-    const reporter = createMemoryLogReporter()
-    const entry = { id: 'log', level: 1, args: ['some messages'], timestamp: new Date() }
-    reporter.write(entry)
-    expect(reporter.logs).toEqual([entry])
-  })
-
-  test('can override id', () => {
-    const reporter = createMemoryLogReporter({ id: 'custom-id-mem' })
-    expect(reporter.id).toBe('custom-id-mem')
-  })
-
-  test('can filter', () => {
-    const reporter = createMemoryLogReporter({ filter(entry) { return entry.id !== 'secret' } })
-    reporter.write({ id: 'ok', level: 1, args: ['some messages'], timestamp: new Date() })
-    reporter.write({ id: 'secret', level: 1, args: ['some messages'], timestamp: new Date() })
-    expect(reporter.logs.length).toBe(1)
-  })
-
-  test('can change filter', () => {
-    const reporter = createMemoryLogReporter()
-    const filter = reporter.filter
-    reporter.filter = entry => entry.id !== 'secret'
-    expect(reporter.filter).not.toEqual(filter)
-  })
-
-  test('formatter can be used to pre-process the log', () => {
-    const reporter = createMemoryLogReporter({
-      formatter: (entry) => ({
-        ...entry,
-        args: entry.args.map(arg => arg === 'secret' ? '<censored>' : arg)
-      })
-    })
-
-    const entry = { id: 'log', level: 1, args: ['a', 'secret', 'b'], timestamp: new Date() }
-    reporter.write(entry)
-
-    expect(reporter.logs[0].args[1]).toBe('<censored>')
-  })
-
-  test('can change formatter', () => {
-    const reporter = createMemoryLogReporter()
-    const formatter = reporter.formatter
-    reporter.formatter = e => ({ ...e, args: e.args.reverse() })
-    expect(reporter.formatter).not.toEqual(formatter)
-  })
-
-  describe('getLogMessages()', () => {
-    test('empty logs returns empty string', () => {
-      const reporter = createMemoryLogReporter()
-
-      expect(reporter.getLogMessage()).toEqual('')
-    })
-
-    test('print args', () => {
-      const reporter = createMemoryLogReporter()
-      const entry = { id: 'log', level: 1, args: ['miku', 'is', 'singing'], timestamp: new Date() }
-      reporter.write(entry)
-      expect(reporter.getLogMessage()).toEqual('miku is singing')
-    })
-
-    test('print object arg', () => {
-      const reporter = createMemoryLogReporter()
-      const entry = { id: 'log', level: 1, args: [{ 'miku': 'sing' }], timestamp: new Date() }
-      reporter.write(entry)
-      expect(reporter.getLogMessage()).toEqual("{ miku: 'sing' }")
-    })
-  })
-
-  describe('getLogMessageWithLevel', () => {
-    test('print with level', () => {
-      const reporter = createMemoryLogReporter()
-      reporter.write({ id: 'log', level: logLevels.info, args: ['msg 1'], timestamp: new Date() })
-      reporter.write({ id: 'log', level: logLevels.warn, args: ['msg 2'], timestamp: new Date() })
-      expect(reporter.getLogMessageWithLevel()).toEqual(`(INFO) msg 1\n(WARN) msg 2`)
-    })
-  })
-})

package/src/memory/MemoryLogReporter.ts

@@ -1,66 +0,0 @@
-import { required } from 'type-plus'
-import { formatLogLevel } from '../formatter'
-import { LogEntry, LogFilter, LogFormatter, LogReporter, LogReporterOptions } from '../types'
-import { assertLogModeIsNotProduction } from '../utils'
-import { toInspectLogEntry } from './toInspectStringForObject'
-
-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/src/memory/index.ts

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

package/src/memory/logEntriesToString.spec.ts

@@ -1,47 +0,0 @@
-import { logLevels, logEntriesToString } from '..'
-
-test('convert log entries to string', () => {
-  const timestamp = new Date(2019, 6)
-  const actual = logEntriesToString([
-    { id: 'log', level: logLevels.emergency, args: ['emergency'], timestamp },
-    { id: 'log', level: logLevels.critical, args: ['critical'], timestamp },
-    { id: 'log', level: logLevels.alert, args: ['alert'], timestamp },
-    { id: 'log', level: logLevels.error, args: ['error'], timestamp },
-    { id: 'log', level: logLevels.warn, args: ['warn'], timestamp },
-    { id: 'log', level: logLevels.notice, args: ['notice'], timestamp },
-    { id: 'log', level: logLevels.info, args: ['info'], timestamp },
-    { id: 'log', level: logLevels.debug, args: ['debug'], timestamp },
-    { id: 'log', level: logLevels.trace, args: ['trace'], timestamp }
-  ])
-
-  const iso = timestamp.toISOString()
-  expect(actual).toEqual(`${iso},log,(EMERGENCY),emergency
-${iso},log,(CRITICAL),critical
-${iso},log,(ALERT),alert
-${iso},log,(ERROR),error
-${iso},log,(WARN),warn
-${iso},log,(NOTICE),notice
-${iso},log,(INFO),info
-${iso},log,(DEBUG),debug
-${iso},log,(TRACE),trace`)
-})
-
-test('print out object', () => {
-  const timestamp = new Date(2021, 4)
-  const actual = logEntriesToString([
-    { id: 'log', level: logLevels.info, args: ['a', { a: 1 }], timestamp }
-  ])
-
-  const iso = timestamp.toISOString()
-  expect(actual).toEqual(`${iso},log,(INFO),a,{ a: 1 }`)
-})
-
-test('print out array', () => {
-  const timestamp = new Date(2021, 4)
-  const actual = logEntriesToString([
-    { id: 'log', level: logLevels.info, args: ['a', [1, 2, 3]], timestamp }
-  ])
-
-  const iso = timestamp.toISOString()
-  expect(actual).toEqual(`${iso},log,(INFO),a,[ 1, 2, 3 ]`)
-})

package/src/memory/logEntriesToString.ts

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

package/src/memory/toInspectStringForObject.ts

@@ -1,13 +0,0 @@
-import isNode from 'is-node'
-import { LogEntry } from '../LogEntry'
-
-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/src/shouldLog.ts

@@ -1,11 +0,0 @@
-import { store } from './store';
-import { LogLevel } from './types';
-
-/**
- * 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/src/store.ts

@@ -1,25 +0,0 @@
-import { createStore } from 'global-store'
-import { getLogModeFromEnvironment } from './getLogModeFromEnvironment'
-import { logLevels } from './logLevel'
-import { LogStore } from './typesInternal'
-
-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
-    }
-  }
-})