@nxtedition/logger 1.0.2 → 1.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/logger",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
@@ -12,7 +12,7 @@
   ],
   "license": "UNLICENSED",
   "scripts": {
-    "build": "rimraf dist && mkdir -p dist && cp src/*.js dist/ && tsc && for f in src/*.ts; do [[ \"$f\" == *.test.ts ]] || { amaroc \"$f\" && mv \"${f%.ts}.js\" dist/; }; done",
+    "build": "rimraf dist && tsc",
     "prepublishOnly": "yarn build",
     "typecheck": "tsc --noEmit",
     "test": "node --test",
@@ -23,5 +23,5 @@
     "pino": "^10.3.1",
     "request-target": "^1.0.2"
   },
-  "gitHead": "403ede8db1350023efdc01a33f1df69b4fb02724"
+  "gitHead": "fd0bcacdf9e7b58fb2a540e0529c6b4961c2b0b5"
 }

package/dist/index.js

@@ -1,2 +0,0 @@
-export * from './logger.js'
-export * from './platform.js'

package/dist/logger.js

@@ -1,83 +0,0 @@
-import { isMainThread } from 'node:worker_threads'
-import serializers from './serializers.js'
-import pino from 'pino'
-                                                                                    
-                                           
-
-                               
-
-                                                   
-                        
-                           
- 
-
-const isProduction = process.env.NODE_ENV === 'production'
-
-export function createLogger(
-  {
-    level = isProduction ? 'debug' : 'trace',
-    flushInterval = 1e3,
-    stream,
-    ...options
-  }                = {},
-  onTerminate          ,
-)         {
-  if (!stream) {
-    if (
-      process.stdout.write !== process.stdout.constructor.prototype.write ||
-      process.stdout.fd == null
-    ) {
-      stream = pino.destination(process.stdout)
-    }
-  }
-
-  if (stream) {
-    // Do nothing...
-  } else if (!isProduction) {
-    stream = pino.destination({ fd: process.stdout.fd ?? 1, sync: true, fsync: false })
-  } else if (!isMainThread) {
-    // TODO (perf): Async mode doesn't work super well in workers.
-    stream = pino.destination({ fd: 1, sync: true, fsync: false })
-  } else {
-    stream = pino.destination({
-      sync: false,
-      fsync: false,
-      minLength: 4 * 1024,
-      maxWrite: 32 * 1024,
-    })
-
-    let flushing = 0
-    const onFlush = () => {
-      flushing--
-    }
-
-    const flushTimeout = setInterval(() => {
-      if (flushing >= 10) {
-        try {
-          logger.warn('logger is flushing too slow')
-          stream?.flushSync()
-        } catch (err) {
-          console.error(err)
-        }
-      } else {
-        flushing++
-        stream?.flush(onFlush)
-      }
-      flushTimeout.refresh()
-    }, flushInterval).unref()
-  }
-
-  const logger = pino(
-    {
-      level,
-      ...options,
-      serializers: {
-        ...serializers,
-        ...options.serializers,
-      },
-    },
-    stream,
-  )
-
-  return logger
-}

package/dist/platform.js

@@ -1,38 +0,0 @@
-export const SIGNALS =
-  typeof process === 'object'
-    ? process.platform === 'linux'
-      ? {
-          129: 'SIGHUP', //  1
-          130: 'SIGINT', //  2
-          131: 'SIGQUIT', //  3
-          132: 'SIGILL', //  4
-          133: 'SIGTRAP', //  5
-          134: 'SIGABRT', //  6
-          135: 'SIGBUS', //  7
-          136: 'SIGFPE', //  8
-          137: 'SIGKILL', //  9
-          138: 'SIGUSR1', // 10
-          139: 'SIGSEGV', // 11
-          140: 'SIGUSR2', // 12
-          141: 'SIGPIPE', // 13
-          142: 'SIGALRM', // 14
-          143: 'SIGTERM', // 15
-          144: 'SIGSTKFLT', // 16
-          145: 'SIGCHLD', // 17
-          146: 'SIGCONT', // 18
-          147: 'SIGSTOP', // 19
-          148: 'SIGTSTP', // 20
-          149: 'SIGTTIN', // 21
-          150: 'SIGTTOU', // 22
-          151: 'SIGURG', // 23
-          152: 'SIGXCPU', // 24
-          153: 'SIGXFSZ', // 25
-          154: 'SIGVTALRM', // 26
-          155: 'SIGPROF', // 27
-          156: 'SIGWINCH', // 28
-          157: 'SIGIO', // 29
-          158: 'SIGPWR', // 30
-          159: 'SIGSYS', // 31
-        }
-      : {}
-    : {}

package/dist/serializers.js

@@ -1,353 +0,0 @@
-import { SIGNALS } from './platform.ts'
-import { parseHeaders } from '@nxtedition/nxt-undici'
-import requestTarget from 'request-target'
-import querystring from 'fast-querystring'
-
-function getHeader(obj, key) {
-  return !obj || !key
-    ? undefined
-    : obj.headers?.[key] || obj.headers?.get?.(key) || obj.getHeader?.(key)
-}
-
-function getHeaders(obj) {
-  if (!obj) {
-    return undefined
-  }
-
-  if (obj.getHeaders) {
-    return obj.getHeaders()
-  }
-
-  if (obj.headers) {
-    return Array.isArray(obj.headers) ? parseHeaders(obj.headers) : obj.headers
-  }
-
-  if (obj.headers?.entries) {
-    return Object.fromEntries(obj.headers.entries())
-  }
-
-  return undefined
-}
-
-function getUrl(obj) {
-  if (!obj) {
-    return undefined
-  }
-
-  const { origin, path, hostname, protocol, port, url } = obj
-
-  if (typeof url === 'string' && url) {
-    return url
-  }
-
-  const href = url?.href
-  if (typeof href === 'string' && href) {
-    return href
-  }
-
-  if (origin && (!path || typeof path === 'string')) {
-    if (typeof origin === 'object') {
-      return `${origin.protocol || 'http:'}//${origin.hostname}:${origin.port || { 'http:': 80, 'https:': 443 }[origin.protocol]}${path || ''}`
-    }
-
-    if (typeof origin === 'string') {
-      if (path?.startsWith('/') && origin.endsWith('/')) {
-        return `${origin.slice(0, -1)}${path || ''}`
-      } else {
-        return `${origin}${path || ''}`
-      }
-    }
-  }
-
-  if (typeof hostname === 'string') {
-    return `${protocol || 'http:'}//${hostname}:${port || { 'http:': 80, 'https:': 443 }[protocol || 'http:']}${path || ''}`
-  }
-
-  if (typeof path === 'string' && path) {
-    return path
-  }
-
-  return null
-}
-
-function getTarget(obj) {
-  if (!obj) {
-    return undefined
-  }
-
-  try {
-    if (obj.target) {
-      return obj.target
-    }
-    if (typeof obj.url === 'string') {
-      return requestTarget(
-        obj.headers ? obj : { url: obj.url, headers: obj.headers ?? {}, socket: obj.socket },
-      )
-    } else {
-      const { origin, path, hostname, protocol, port, search, query } = obj
-      return {
-        origin,
-        protocol: protocol || undefined,
-        hostname: hostname || undefined,
-        port: port || undefined,
-        pathname: path || undefined,
-        search:
-          search ||
-          (typeof query === 'object' && query != null ? querystring.stringify(query) : undefined),
-      }
-    }
-  } catch {
-    return undefined
-  }
-
-  // TODO(fix): What if url is instanceof URL?
-}
-
-export default {
-  err: (err) => errSerializer(err),
-  error: (err) => errSerializer(err),
-  errors: (err) => errSerializer(err),
-  socket: (socket) =>
-    socket && {
-      id: socket.id || undefined,
-      version: socket.version || undefined,
-      user: socket.user || undefined,
-      userAgent: socket.userAgent || undefined,
-      remoteAddress: socket.remoteAddress || undefined,
-      headers: socket.headers,
-    },
-  req: (req) =>
-    req && {
-      id: req.id || getHeader(req, 'request-id'),
-      httpVersion: req.httpVersion,
-      method: req.method,
-      target: getTarget(req),
-      url: getUrl(req),
-      headers: getHeaders(req),
-      timing: req.timing,
-      bytesRead: req.bytesRead >= 0 ? req.bytesRead : undefined,
-      bytesReadPerSecond:
-        req.bytesReadPerSecond ??
-        (req.timing?.end > 0 && req.bytesRead > 0
-          ? (req.bytesRead * 1e3) / req.timing.end
-          : undefined),
-      remoteAddress: req.socket?.remoteAddress,
-      remotePort: req.socket?.remotePort,
-      aborted: req.aborted,
-      closed: req.closed,
-      destroyed: req.destroyed,
-    },
-  ureq: (ureq) =>
-    ureq && {
-      id: ureq.id || getHeader(ureq, 'request-id'),
-      httpVersion: ureq.httpVersion,
-      method: ureq.method,
-      target: getTarget(ureq),
-      url: getUrl(ureq),
-      headers: getHeaders(ureq),
-      timing: ureq.timing,
-      bytesWritten: ureq.bytesWritten,
-      bytesReadPerSecond:
-        ureq.bytesWrittenPerSecond ??
-        (ureq.timing && ureq.timing.data > 0 && ureq.timing.end > 0
-          ? (ureq.bytesWritten * 1e3) / (ureq.timing.end - ureq.timing.data)
-          : undefined),
-      body: typeof ureq.body === 'string' ? ureq.body : undefined,
-    },
-  res: (res) =>
-    res && {
-      id: res.id || getHeader(res, 'request-id') || getHeader(res.req, 'request-id'),
-      httpVersion: res.httpVersion,
-      headers: getHeaders(res),
-      statusCode: res.statusCode || res.status,
-      timing: res.timing,
-      bytesWritten: res.bytesWritten >= 0 ? res.bytesWritten : undefined,
-      bytesWrittenPerSecond:
-        res.bytesWrittenPerSecond ??
-        (res.timing?.end > 0 && res.bytesWritten > 0
-          ? (res.bytesWritten * 1e3) / res.timing.end
-          : undefined),
-      headersSent: res.headersSent,
-      aborted: res.aborted,
-      closed: res.closed,
-      destroyed: res.destroyed,
-    },
-  ures: (ures) =>
-    ures && {
-      id: ures.id || getHeader(ures, 'request-id') || getHeader(ures.req, 'request-id'),
-      httpVersion: ures.httpVersion,
-      headers: getHeaders(ures),
-      statusCode: ures.statusCode ?? ures.status,
-      timing: ures.timing,
-      bytesRead: ures.bytesRead,
-      bytesReadPerSecond:
-        ures.bytesReadPerSecond ??
-        (ures.timing && ures.timing.data > 0 && ures.timing.end > 0
-          ? (ures.bytesRead * 1e3) / (ures.timing.end - ures.timing.data)
-          : undefined),
-      body: typeof ures.body === 'string' ? ures.body : undefined,
-    },
-}
-
-// TODO (fix): Merge with errros/serializeError.
-// Note that 'data' here should be string while in "serializeError" it should be object.
-// Maybe we should rename serializeError to makeErrorObject or somehting??
-
-// Based on: https://github.com/pinojs/pino-std-serializers
-
-const seen = Symbol('circular-ref-tag')
-export const rawSymbol = Symbol('pino-raw-err-ref')
-
-const pinoErrProto = Object.create(
-  {},
-  {
-    type: {
-      enumerable: true,
-      writable: true,
-      value: undefined,
-    },
-    message: {
-      enumerable: true,
-      writable: true,
-      value: undefined,
-    },
-    stack: {
-      enumerable: true,
-      writable: true,
-      value: undefined,
-    },
-    errors: {
-      enumerable: true,
-      writable: true,
-      value: undefined,
-    },
-    raw: {
-      enumerable: false,
-      get: function () {
-        return this[rawSymbol]
-      },
-      set: function (val) {
-        this[rawSymbol] = val
-      },
-    },
-  },
-)
-Object.defineProperty(pinoErrProto, rawSymbol, {
-  writable: true,
-  value: {},
-})
-
-function errSerializer(err) {
-  if (Array.isArray(err)) {
-    return err.length === 0 ? undefined : errSerializer({ message: '', errors: err })
-  }
-
-  if (!isErrorLike(err)) {
-    return undefined
-  }
-
-  const errors = Array.isArray(err?.errors)
-    ? err.errors.map((err) => errSerializer(err)).filter(Boolean)
-    : null
-
-  if (err.message === '' && errors != null && errors.length === 0) {
-    return undefined
-  }
-
-  if (err.message === '' && errors != null && errors.length === 1) {
-    return errSerializer(err.errors[0])
-  }
-
-  err[seen] = undefined // tag to prevent re-looking at this
-  const _err = Object.create(pinoErrProto)
-  _err.type =
-    Object.prototype.toString.call(err.constructor) === '[object Function]'
-      ? err.constructor.name
-      : err.name
-  _err.name = err.name
-  _err.message = err.message
-  _err.stack = err.stack
-
-  if (errors != null) {
-    _err.errors = errors
-  }
-
-  if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) {
-    _err.cause = errSerializer(err.cause)
-  }
-
-  for (const key in err) {
-    if (_err[key] === undefined) {
-      const val = err[key]
-      if (isErrorLike(val)) {
-        if (!Object.prototype.hasOwnProperty.call(val, seen)) {
-          _err[key] = errSerializer(val)
-        }
-      } else if (typeof val === 'bigint') {
-        _err[key] = `${val.toString()}`
-      } else if (val != null && !/^[A-Z0-9_]+$/.test(key)) {
-        _err[key] = val
-      }
-    }
-  }
-
-  if (_err.data != null && typeof _err.data !== 'string') {
-    try {
-      _err.data = JSON.stringify(_err.data, (k, v) => (typeof v === 'bigint' ? v.toString() : v), 2)
-    } catch {
-      // Do nothing...
-    }
-  }
-
-  if (_err.body != null && typeof _err.body !== 'string') {
-    try {
-      _err.body = JSON.stringify(_err.body, (k, v) => (typeof v === 'bigint' ? v.toString() : v), 2)
-    } catch {
-      // Do nothing...
-    }
-  }
-
-  if (_err.meta != null && typeof _err.meta !== 'string') {
-    try {
-      _err.meta = JSON.stringify(_err.meta, (k, v) => (typeof v === 'bigint' ? v.toString() : v), 2)
-    } catch {
-      // Do nothing...
-    }
-  }
-
-  if (_err.code != null && typeof _err.code !== 'string') {
-    _err.code = String(_err.code)
-  }
-
-  if (_err.emitter != null && typeof _err.emitter === 'object') {
-    _err.emitter = undefined
-  }
-
-  if (_err.statusCode == null && _err.status != null) {
-    _err.statusCode = Number(_err.status) || undefined
-  }
-
-  if (_err.signalCode == null && _err.signal != null) {
-    _err.signalCode = SIGNALS[_err._signal] ?? _err._signal
-  } else if (_err.signalCode != null) {
-    _err.signalCode = SIGNALS[_err.signalCode] ?? _err.signalCode
-  }
-
-  if (_err.exitCode == null && _err.code != null && /^([A-Z]+|[a-z]+|[0-9]+)$/.test(_err.code)) {
-    _err.exitCode = String(_err.code)
-  }
-
-  delete err[seen] // clean up tag in case err is serialized again later
-  _err.raw = err
-  return _err
-}
-
-const isErrorLike = (err) => {
-  return (
-    err &&
-    (typeof err.message === 'string' ||
-      typeof err.status === 'number' ||
-      typeof err.statusCode === 'number' ||
-      typeof err.code === 'string')
-  )
-}