@nxtedition/lib 23.5.14 → 23.6.1

package/http.js

@@ -33,101 +33,128 @@ function onTimeout() {
   this.destroy((timeoutError ??= new createError.RequestTimeout()))
 }
 
+// TODO (fix): Make custom ServerRequest class with the properties
+// that is currently deprecated by Context.
+
 export class Context {
   #id
   #userAgent
   #req
   #res
   #ac
-  #url
+  #target
   #logger
   #query
 
   constructor(req, res, logger) {
     assert(req)
     assert(res)
-    assert(logger)
-
-    const id = req.headers['request-id'] || req.headers['Request-Id']
 
-    this.#id = (id ? `${id},` : '') + genReqId()
+    this.#id = req.id || req.headers['request-id'] || req.headers['Request-Id'] || genReqId()
     this.#userAgent = req.headers['user-agent'] || req.headers['User-Agent'] || ''
     this.#req = req
     this.#res = res
-    this.#logger = logger.child({ reqId: this.#id, url: req.url, userAgent: this.#userAgent })
+    this.#logger = logger.child({ req: { id: this.#req.id } })
+    this.#target = requestTarget(this.#req)
+    this.#query = undefined
+
+    // TODO (fix): This should not be necessary...
+    req.target ??= this.#target
+    req.userAgent ??= this.#userAgent
+    req.id ??= this.#id
+    req.logger ??= this.#logger
   }
 
   get id() {
+    if (this.#req.id) {
+      return this.#req.id
+    }
+
     return this.#id
   }
 
+  get logger() {
+    return this.#logger
+  }
+
+  get req() {
+    return this.#req
+  }
+
+  get res() {
+    return this.#res
+  }
+
+  get [kAbortController]() {
+    return this.#ac
+  }
+
+  get signal() {
+    this.#ac ??= new AbortController()
+    return this.#ac.signal
+  }
+
+  /** @deprecated */
   get userAgent() {
+    if (this.#req.userAgent) {
+      return this.#req.userAgent
+    }
+
     return this.#userAgent
   }
 
+  /** @deprecated */
   get method() {
     return this.#req.method
   }
 
+  /** @deprecated */
   get url() {
-    if (this.#url === undefined) {
-      this.#url = requestTarget(this.#req)
+    if (this.#req.target) {
+      return this.#req.target
     }
 
-    if (!this.#url) {
+    this.#target ??= requestTarget(this.#req)
+
+    if (!this.#target) {
       throw new createError.BadRequest('invalid url')
     }
 
-    return this.#url
+    return this.#target
   }
 
+  /** @deprecated */
   set url(value) {
-    if (value instanceof URL) {
-      value = value.toString()
-    }
-
     if (typeof value !== 'string') {
       throw new Error('url must be a string')
     }
 
     this.#req.url = value
-    this.#url = undefined
+    this.#target = undefined
     this.#query = undefined
   }
 
+  /** @deprecated */
   get query() {
-    if (this.#query === undefined) {
-      this.#query =
-        this.url.search.length > 1 ? Object.freeze(querystring.parse(this.url.search.slice(1))) : {}
+    if (this.#req.query) {
+      return this.#req.query
     }
-    return this.#query
-  }
-
-  set query(value) {}
 
-  get logger() {
-    return this.#logger
-  }
+    this.#query ??=
+      this.#target.search.length > 1
+        ? Object.freeze(querystring.parse(this.#target.search.slice(1)))
+        : {}
 
-  set logger(val) {
-    this.#logger = val
-  }
-
-  get req() {
-    return this.#req
-  }
-
-  get res() {
-    return this.#res
+    return this.#query
   }
 
-  get [kAbortController]() {
-    return this.#ac
-  }
+  /** @deprecated */
+  set query(value) {}
 
-  get signal() {
-    this.#ac ??= new AbortController()
-    return this.#ac.signal
+  /** @deprecated */
+  set logger(logger) {
+    this.#logger = logger.child({ req: { id: this.#req.id } })
+    this.#req.logger = this.#logger
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "23.5.14",
+  "version": "23.6.1",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -43,7 +43,8 @@
     "timeline.js",
     "transcript.js",
     "docker-secrets.js",
-    "wordwrap.js"
+    "wordwrap.js",
+    "under-pressure.js"
   ],
   "scripts": {
     "prepublishOnly": "pinst --disable",

package/serializers.js

@@ -2,7 +2,9 @@ import { SIGNALS } from './platform.js'
 import { parseHeaders } from '@nxtedition/nxt-undici'
 
 function getHeader(obj, key) {
-  return obj?.headers?.get?.(key) || obj?.getHeader?.(key) || obj?.headers?.[key]
+  return !obj || !key
+    ? undefined
+    : obj?.headers?.get?.(key) || obj?.getHeader?.(key) || obj?.headers?.[key]
 }
 
 function getHeaders(obj) {
@@ -91,8 +93,8 @@ export default {
     },
   res: (res) =>
     res && {
-      id: res.id || res.req?.id || getHeader(res, 'request-id') || getHeader(res.req, 'request-id'),
-      userAgent: res.userAgent ?? getHeader(res, 'user-agent'),
+      id: res.id ?? res.req?.id ?? getHeader(res, 'request-id') ?? getHeader(res.req, 'request-id'),
+      userAgent: res.userAgent ?? res.req?.userAgent ?? getHeader(res.req, 'user-agent'),
       timing: getTiming(res),
       statusCode: res.statusCode || res.status,
       bytesWritten: res.bytesWritten,
@@ -112,14 +114,11 @@ export default {
       id: req.id || getHeader(req, 'request-id'),
       userAgent: req.userAgent ?? getHeader(req, 'user-agent'),
       timing: getTiming(req),
+      target: req.target,
       method: req.method,
       url: req.url,
-      scheme: req.scheme,
-      host: req.host,
-      port: req.port,
-      path: req.path,
-      query: req.query,
       headers: getHeaders(req),
+      query: req.query,
       bytesRead: req.bytesRead,
       bytesReadPerSecond:
         req.bytesReadPerSecond ??
@@ -152,8 +151,8 @@ export default {
       id: ureq.id || getHeader(ureq, 'request-id'),
       userAgent: ureq.userAgent ?? getHeader(ureq, 'user-agent'),
       timing: getTiming(ureq),
-      method: ureq.method,
       url: getUrl(ureq),
+      method: ureq.method,
       body: typeof ureq.body === 'string' ? ureq.body : undefined,
       bytesWritten: ureq.bytesWritten,
       bytesReadPerSecond:

package/under-pressure.js

@@ -0,0 +1,105 @@
+// Based on: https://github.com/fastify/under-pressure/blob/main/index.js
+import { monitorEventLoopDelay } from 'node:perf_hooks'
+
+function getSampleInterval(value, eventLoopResolution) {
+  const sampleInterval = value || 1000
+
+  return Math.max(eventLoopResolution, sampleInterval)
+}
+
+export default function (opts = {}) {
+  const resolution = 10
+  const sampleInterval = getSampleInterval(opts.sampleInterval, resolution)
+  const maxEventLoopDelay = opts.maxEventLoopDelay || 0
+  const maxHeapUsedBytes = opts.maxHeapUsedBytes || 0
+  const maxRssBytes = opts.maxRssBytes || 0
+  const healthCheck = opts.healthCheck || false
+  const maxEventLoopUtilization = opts.maxEventLoopUtilization || 0
+
+  const checkMaxEventLoopDelay = maxEventLoopDelay > 0
+  const checkMaxHeapUsedBytes = maxHeapUsedBytes > 0
+  const checkMaxRssBytes = maxRssBytes > 0
+  const checkMaxEventLoopUtilization = maxEventLoopUtilization > 0
+
+  let heapUsed = 0
+  let rssBytes = 0
+  let eventLoopDelay = 0
+  let elu
+  let eventLoopUtilized = 0
+
+  const histogram = monitorEventLoopDelay({ resolution })
+  histogram.enable()
+
+  if (performance.eventLoopUtilization) {
+    elu = performance.eventLoopUtilization()
+  }
+
+  const timer = setTimeout(beginMemoryUsageUpdate, sampleInterval)
+  timer.unref()
+
+  if (
+    checkMaxEventLoopUtilization === false &&
+    checkMaxEventLoopDelay === false &&
+    checkMaxHeapUsedBytes === false &&
+    checkMaxRssBytes === false &&
+    healthCheck === false
+  ) {
+    return
+  }
+
+  function updateEventLoopDelay() {
+    eventLoopDelay = Math.max(0, histogram.mean / 1e6 - resolution)
+    if (Number.isNaN(eventLoopDelay)) eventLoopDelay = Infinity
+    histogram.reset()
+  }
+
+  function updateEventLoopUtilization() {
+    if (elu) {
+      eventLoopUtilized = performance.eventLoopUtilization(elu).utilization
+    } else {
+      eventLoopUtilized = 0
+    }
+  }
+
+  function beginMemoryUsageUpdate() {
+    updateMemoryUsage()
+    timer.refresh()
+  }
+
+  function updateMemoryUsage() {
+    const mem = process.memoryUsage()
+    heapUsed = mem.heapUsed
+    rssBytes = mem.rss
+    updateEventLoopDelay()
+    updateEventLoopUtilization()
+  }
+
+  return {
+    isUnderPressure() {
+      if (checkMaxEventLoopDelay && eventLoopDelay > maxEventLoopDelay) {
+        return true
+      }
+
+      if (checkMaxHeapUsedBytes && heapUsed > maxHeapUsedBytes) {
+        return true
+      }
+
+      if (checkMaxRssBytes && rssBytes > maxRssBytes) {
+        return true
+      }
+
+      return checkMaxEventLoopUtilization && eventLoopUtilized > maxEventLoopUtilization
+    },
+    memoryUsage() {
+      return {
+        eventLoopDelay,
+        rssBytes,
+        heapUsed,
+        eventLoopUtilized,
+      }
+    },
+    [Symbol.dispose]() {
+      clearTimeout(timer)
+    },
+  }
+}