@nxtedition/lib 23.13.0 → 23.14.1

package/fixed-queue.js

@@ -0,0 +1,113 @@
+// Extracted from node/lib/internal/fixed_queue.js
+
+// Currently optimal queue size, tested on V8 6.0 - 6.6. Must be power of two.
+const kSize = 2048
+const kMask = kSize - 1
+
+// The FixedQueue is implemented as a singly-linked list of fixed-size
+// circular buffers. It looks something like this:
+//
+//  head                                                       tail
+//    |                                                          |
+//    v                                                          v
+// +-----------+ <-----\       +-----------+ <------\         +-----------+
+// |  [null]   |        \----- |   next    |         \------- |   next    |
+// +-----------+               +-----------+                  +-----------+
+// |   item    | <-- bottom    |   item    | <-- bottom       |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |                  |  [empty]  |
+// |   item    |               |   item    |       bottom --> |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |    ...    |               |    ...    |                  |    ...    |
+// |   item    |               |   item    |                  |   item    |
+// |   item    |               |   item    |                  |   item    |
+// |  [empty]  | <-- top       |   item    |                  |   item    |
+// |  [empty]  |               |   item    |                  |   item    |
+// |  [empty]  |               |  [empty]  | <-- top  top --> |  [empty]  |
+// +-----------+               +-----------+                  +-----------+
+//
+// Or, if there is only one circular buffer, it looks something
+// like either of these:
+//
+//  head   tail                                 head   tail
+//    |     |                                     |     |
+//    v     v                                     v     v
+// +-----------+                               +-----------+
+// |  [null]   |                               |  [null]   |
+// +-----------+                               +-----------+
+// |  [empty]  |                               |   item    |
+// |  [empty]  |                               |   item    |
+// |   item    | <-- bottom            top --> |  [empty]  |
+// |   item    |                               |  [empty]  |
+// |  [empty]  | <-- top            bottom --> |   item    |
+// |  [empty]  |                               |   item    |
+// +-----------+                               +-----------+
+//
+// Adding a value means moving `top` forward by one, removing means
+// moving `bottom` forward by one. After reaching the end, the queue
+// wraps around.
+//
+// When `top === bottom` the current queue is empty and when
+// `top + 1 === bottom` it's full. This wastes a single space of storage
+// but allows much quicker checks.
+
+class FixedCircularBuffer {
+  constructor() {
+    this.bottom = 0
+    this.top = 0
+    this.list = new Array(kSize)
+    this.next = null
+  }
+
+  isEmpty() {
+    return this.top === this.bottom
+  }
+
+  isFull() {
+    return ((this.top + 1) & kMask) === this.bottom
+  }
+
+  push(data) {
+    this.list[this.top] = data
+    this.top = (this.top + 1) & kMask
+  }
+
+  shift() {
+    const nextItem = this.list[this.bottom]
+    if (nextItem === undefined) return null
+    this.list[this.bottom] = undefined
+    this.bottom = (this.bottom + 1) & kMask
+    return nextItem
+  }
+}
+
+export class FixedQueue {
+  constructor() {
+    this.head = this.tail = new FixedCircularBuffer()
+    this.size = 0
+  }
+
+  isEmpty() {
+    return this.head.isEmpty()
+  }
+
+  push(data) {
+    if (this.head.isFull()) {
+      // Head is full: Creates a new queue, sets the old queue's `.next` to it,
+      // and sets it as the new main queue.
+      this.head = this.head.next = new FixedCircularBuffer()
+    }
+    this.head.push(data)
+  }
+
+  shift() {
+    const tail = this.tail
+    const next = tail.shift()
+    if (tail.isEmpty() && tail.next !== null) {
+      // If there is another queue, it forms the new tail.
+      this.tail = tail.next
+    }
+    return next
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "23.13.0",
+  "version": "23.14.1",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -10,6 +10,7 @@
     "rxjs/*",
     "util/*",
     "cache.js",
+    "fixed-queue.js",
     "http-client.js",
     "subtract-ranges.js",
     "serializers.js",
@@ -44,7 +45,8 @@
     "transcript.js",
     "docker-secrets.js",
     "wordwrap.js",
-    "under-pressure.js"
+    "under-pressure.js",
+    "yield.js"
   ],
   "scripts": {
     "prepublishOnly": "pinst --disable",

package/serializers.js

@@ -1,5 +1,6 @@
 import { SIGNALS } from './platform.js'
 import { parseHeaders } from '@nxtedition/nxt-undici'
+import requestTarget from 'request-target'
 
 function getHeader(obj, key) {
   return !obj || !key
@@ -71,13 +72,28 @@ function getTiming(obj) {
     return undefined
   }
   return {
-    connect: timing.connect ?? -1,
-    headers: timing.headers ?? -1,
-    data: timing.data ?? -1,
-    end: timing.end ?? timing.complete ?? timing.error ?? -1,
+    connect: timing.connect > 0 ? Math.ceil(timing.connect * 1e3) : undefined,
+    headers: timing.headers > 0 ? Math.ceil(timing.headers * 1e3) : undefined,
+    data: timing.data > 0 ? Math.ceil(timing.data * 1e3) : undefined,
+    end: timing.end > 0 ? Math.ceil(timing.end * 1e3) : undefined,
   }
 }
 
+function getTarget(obj) {
+  if (!obj) {
+    return undefined
+  }
+  if (obj.target) {
+    return obj.target
+  }
+  if (typeof obj.url === 'string') {
+    // TODO(fix): What if url is a full url?
+    return requestTarget({ url: obj.url, headers: obj.headers ?? {}, socket: obj.socket })
+  }
+
+  // TODO(fix): What if url is instanceof URL?
+}
+
 export default {
   err: (err) => errSerializer(err),
   error: (err) => errSerializer(err),
@@ -91,37 +107,16 @@ export default {
       remoteAddress: socket.remoteAddress || undefined,
       headers: socket.headers,
     },
-  res: (res) =>
-    res && {
-      id: res.id ?? res.req?.id ?? getHeader(res, 'request-id') ?? getHeader(res.req, 'request-id'),
-      url: res.req?.url,
-      method: res.req?.method,
-      headers: getHeaders(res),
-      statusCode: res.statusCode || res.status,
-      timing: getTiming(res),
-      bytesWritten: res.bytesWritten,
-      bytesWrittenPerSecond:
-        res.bytesWrittenPerSecond ??
-        (res.timing?.complete > 0 && res.bytesWritten
-          ? (res.bytesWritten * 1e3) / res.timing.complete
-          : undefined),
-      headersSent: res.headersSent,
-      aborted: res.aborted,
-      closed: res.closed,
-      destroyed: res.destroyed,
-    },
   req: (req) =>
     req && {
-      id: req.id || getHeader(req, 'request-id'),
-      url: req.url,
       method: req.method,
       headers: getHeaders(req),
-      target: req.target,
+      target: getTarget(req),
       timing: getTiming(req),
-      bytesRead: req.bytesRead,
+      bytesRead: req.bytesRead >= 0 ? req.bytesRead : undefined,
       bytesReadPerSecond:
         req.bytesReadPerSecond ??
-        (req.timing?.complete > 0 && req.bytesRead
+        (req.timing?.complete > 0 && req.bytesRead > 0
           ? (req.bytesRead * 1e3) / req.timing.complete
           : undefined),
       remoteAddress: req.socket?.remoteAddress,
@@ -130,20 +125,21 @@ export default {
       closed: req.closed,
       destroyed: req.destroyed,
     },
-  ures: (ures) =>
-    ures && {
-      id: ures.id || getHeader(ures, 'request-id') || getHeader(ures.req, 'request-id'),
-      userAgent: ures.userAgent ?? getHeader(ures, 'user-agent'),
-      timing: getTiming(ures),
-      statusCode: ures.statusCode ?? ures.status,
-      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)
+  res: (res) =>
+    res && {
+      headers: getHeaders(res),
+      statusCode: res.statusCode || res.status,
+      timing: getTiming(res),
+      bytesWritten: res.bytesWritten >= 0 ? res.bytesWritten : undefined,
+      bytesWrittenPerSecond:
+        res.bytesWrittenPerSecond ??
+        (res.timing?.complete > 0 && res.bytesWritten > 0
+          ? (res.bytesWritten * 1e3) / res.timing.complete
           : undefined),
-      body: typeof ures.body === 'string' ? ures.body : undefined,
-      headers: getHeaders(ures),
+      headersSent: res.headersSent,
+      aborted: res.aborted,
+      closed: res.closed,
+      destroyed: res.destroyed,
     },
   ureq: (ureq) =>
     ureq && {
@@ -162,6 +158,21 @@ export default {
       headers: getHeaders(ureq),
       query: ureq.query,
     },
+  ures: (ures) =>
+    ures && {
+      id: ures.id || getHeader(ures, 'request-id') || getHeader(ures.req, 'request-id'),
+      userAgent: ures.userAgent ?? getHeader(ures, 'user-agent'),
+      timing: getTiming(ures),
+      statusCode: ures.statusCode ?? ures.status,
+      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,
+      headers: getHeaders(ures),
+    },
 }
 
 // TODO (fix): Merge with errros/serializeError.

package/yield.js

@@ -0,0 +1,58 @@
+import { FixedQueue } from './fixed-queue.js'
+
+const yieldTimeout = 50
+const yieldQueue = new FixedQueue()
+let yieldScheduled = false
+let yieldTime = performance.now()
+let yieldActive = false
+
+export function maybeYield(opts, callback) {
+  if (callback != null && typeof callback !== 'function') {
+    throw new TypeError('callback must be a function')
+  }
+
+  return performance.now() - yieldTime < yieldTimeout ? null : doYield(opts, callback)
+}
+
+export function doYield(opts, callback) {
+  if (!yieldScheduled) {
+    yieldScheduled = true
+    setImmediate(dispatchYield)
+  }
+
+  if (callback) {
+    yieldQueue.push(callback)
+    return true
+  } else {
+    return new Promise((resolve) => {
+      yieldQueue.push(resolve)
+    })
+  }
+}
+
+function dispatchYield() {
+  if (yieldActive) {
+    return
+  }
+
+  yieldActive = true
+  yieldTime = performance.now()
+
+  while (!yieldQueue.isEmpty()) {
+    const resolve = yieldQueue.shift()
+
+    resolve(null)
+
+    if (performance.now() - yieldTime > yieldTimeout) {
+      setImmediate(dispatchYield)
+      return
+    }
+  }
+
+  yieldActive = false
+  yieldScheduled = false
+}
+
+setInterval(() => {
+  yieldTime = performance.now()
+}, 500).unref()