@nxtedition/logger 1.0.0

package/lib/logger.d.ts

@@ -0,0 +1,9 @@
+import type { Logger as PinoLogger, LoggerOptions as PinoLoggerOptions } from 'pino';
+import type { SonicBoom } from 'sonic-boom';
+export type Logger = PinoLogger;
+interface LoggerOptions extends PinoLoggerOptions {
+    flushInterval?: number;
+    stream?: SonicBoom | null;
+}
+export declare function createLogger({ level, flushInterval, stream, ...options }?: LoggerOptions, onTerminate?: unknown): Logger;
+export {};

package/lib/logger.js

@@ -0,0 +1,83 @@
+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/lib/platform.d.ts

@@ -0,0 +1,65 @@
+export declare const SIGNALS: {
+    129: string;
+    130: string;
+    131: string;
+    132: string;
+    133: string;
+    134: string;
+    135: string;
+    136: string;
+    137: string;
+    138: string;
+    139: string;
+    140: string;
+    141: string;
+    142: string;
+    143: string;
+    144: string;
+    145: string;
+    146: string;
+    147: string;
+    148: string;
+    149: string;
+    150: string;
+    151: string;
+    152: string;
+    153: string;
+    154: string;
+    155: string;
+    156: string;
+    157: string;
+    158: string;
+    159: string;
+} | {
+    129?: undefined;
+    130?: undefined;
+    131?: undefined;
+    132?: undefined;
+    133?: undefined;
+    134?: undefined;
+    135?: undefined;
+    136?: undefined;
+    137?: undefined;
+    138?: undefined;
+    139?: undefined;
+    140?: undefined;
+    141?: undefined;
+    142?: undefined;
+    143?: undefined;
+    144?: undefined;
+    145?: undefined;
+    146?: undefined;
+    147?: undefined;
+    148?: undefined;
+    149?: undefined;
+    150?: undefined;
+    151?: undefined;
+    152?: undefined;
+    153?: undefined;
+    154?: undefined;
+    155?: undefined;
+    156?: undefined;
+    157?: undefined;
+    158?: undefined;
+    159?: undefined;
+};

package/lib/platform.js

@@ -0,0 +1,38 @@
+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/lib/serializers.d.ts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    function err(err: any): any;
+    function error(err: any): any;
+    function errors(err: any): any;
+    function socket(socket: any): any;
+    function req(req: any): any;
+    function ureq(ureq: any): any;
+    function res(res: any): any;
+    function ures(ures: any): any;
+}
+export default _default;
+export const rawSymbol: unique symbol;

package/lib/serializers.js

@@ -0,0 +1,353 @@
+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')
+  )
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@nxtedition/logger",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib"
+  ],
+  "license": "UNLICENSED",
+  "scripts": {
+    "build": "rimraf lib && mkdir -p lib && cp src/*.js lib/ && tsc && for f in src/*.ts; do [[ \"$f\" == *.test.ts ]] || { amaroc \"$f\" && mv \"${f%.ts}.js\" lib/; }; done",
+    "prepublishOnly": "yarn build",
+    "typecheck": "tsc --noEmit",
+    "test": "node --test",
+    "test:ci": "node --test"
+  },
+  "dependencies": {
+    "fast-querystring": "^1.1.2",
+    "pino": "^10.3.1",
+    "request-target": "^1.0.2"
+  }
+}