@nxtedition/lib 26.4.5 → 26.4.7

package/app.js

@@ -129,8 +129,26 @@ export function makeApp(appConfig, onTerminate) {
   const serviceModule = appConfig.module ?? 'main'
   const serviceWorkerId = appConfig.workerId ?? threadId
   const serviceInstanceId =
-    // process.env.name is the pm2 name of the process
-    appConfig.instanceId ?? appConfig.containerId ?? process.env.name ?? os.hostname()
+    appConfig.instanceId ??
+    appConfig.containerId ??
+    (() => {
+      if (!isProduction) {
+        // We are not running in docker, so we use pid as instance id.
+        return `pid${process.pid}`
+      }
+
+      try {
+        // Normally we have the container ID as hostname, but that can be changed
+        // so we read it from mountinfo instead. This is not 100% reliable as it
+        // depends on the container runtime.
+        return fs
+          .readFileSync('/proc/self/mountinfo', { encoding: 'utf8' })
+          .match(/[/]([0-9a-f]{64})[/]hostname/)[1]
+          .slice(0, 12)
+      } catch {}
+
+      return os.hostname()
+    })()
 
   if (!serviceName) {
     throw new Error('Service name is required')
@@ -141,7 +159,7 @@ export function makeApp(appConfig, onTerminate) {
     (serviceName &&
       `${serviceName}/${
         serviceVersion || '*'
-      } (module:${serviceModule}; instance:${serviceInstanceId}) worker:${serviceWorkerId} Node/${process.version}`) ??
+      } (module:${serviceModule}; instance:${serviceInstanceId}; worker:${serviceWorkerId}) Node/${process.version}`) ??
     null)
 
   if (isMainThread && serviceName) {

package/http.js

@@ -423,6 +423,7 @@ export class ServerResponse extends http.ServerResponse {
 
   /**
    * @returns {{
+   *   created: number,
    *   connect: number,
    *   headers: number,
    *   data: number,
@@ -431,6 +432,7 @@ export class ServerResponse extends http.ServerResponse {
    */
   get timing() {
     return {
+      created: performance.timeOrigin + this.#created,
       connect: this.#connect,
       headers: this.#headers,
       data: this.#data,
@@ -656,8 +658,18 @@ export class Http2ServerResponse extends http2.Http2ServerResponse {
   #data = -1
   #end = -1
 
+  /**
+   * @returns {{
+   *   created: number,
+   *   connect: number,
+   *   headers: number,
+   *   data: number,
+   *   end: number
+   * }}
+   */
   get timing() {
     return {
+      created: performance.timeOrigin + this.#created,
       connect: this.#connect,
       headers: this.#headers,
       data: this.#data,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "26.4.5",
+  "version": "26.4.7",
   "license": "MIT",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",

package/rxjs/retry.js

@@ -0,0 +1,112 @@
+import { operate } from 'rxjs/internal/util/lift'
+import { createOperatorSubscriber } from 'rxjs/internal/operators/OperatorSubscriber'
+import { identity, timer } from 'rxjs'
+import { innerFrom } from 'rxjs/internal/observable/innerFrom'
+
+// This is from https://github.com/ReactiveX/rxjs/blob/7.x/src/internal/operators/retry.ts
+// But with some custom code added to emit a value on each retry attempt.
+// The default delay function is also changed to use exponential backoff, capped at 1 minute.
+//
+// It uses internals from rxjs, but otherwise the code would have to be modified more heavily.
+
+const DEFAULT_DELAY = (err, retryCount) => {
+  return timer(Math.min(2 ** (retryCount - 1) * 1000, 60_000))
+}
+
+export function retry(configOrCount) {
+  let config
+  if (configOrCount && typeof configOrCount === 'object') {
+    config = configOrCount
+  } else {
+    config = {
+      count: configOrCount,
+    }
+  }
+  const { count = Infinity, delay = DEFAULT_DELAY, resetOnSuccess = false, emitOnRetry } = config
+
+  return count <= 0
+    ? identity
+    : operate((source, subscriber) => {
+        let soFar = 0
+        let innerSub
+        const subscribeForRetry = () => {
+          let syncUnsub = false
+          innerSub = source.subscribe(
+            createOperatorSubscriber(
+              subscriber,
+              (value) => {
+                // If we're resetting on success
+                if (resetOnSuccess) {
+                  soFar = 0
+                }
+                subscriber.next(value)
+              },
+              // Completions are passed through to consumer.
+              undefined,
+              (err) => {
+                if (soFar++ < count) {
+                  // We are still under our retry count
+                  const resub = () => {
+                    if (innerSub) {
+                      innerSub.unsubscribe()
+                      innerSub = null
+                      subscribeForRetry()
+                    } else {
+                      syncUnsub = true
+                    }
+                  }
+
+                  // ------- START CUSTOM CODE -------
+                  if (emitOnRetry) {
+                    try {
+                      subscriber.next(emitOnRetry(err, soFar))
+                    } catch (e) {
+                      subscriber.error(e)
+                      return
+                    }
+                  }
+                  // ------- END CUSTOM CODE -------
+
+                  if (delay != null) {
+                    // The user specified a retry delay.
+                    // They gave us a number, use a timer, otherwise, it's a function,
+                    // and we're going to call it to get a notifier.
+                    const notifier =
+                      typeof delay === 'number' ? timer(delay) : innerFrom(delay(err, soFar))
+                    const notifierSubscriber = createOperatorSubscriber(
+                      subscriber,
+                      () => {
+                        // After we get the first notification, we
+                        // unsubscribe from the notifier, because we don't want anymore
+                        // and we resubscribe to the source.
+                        notifierSubscriber.unsubscribe()
+                        resub()
+                      },
+                      () => {
+                        // The notifier completed without emitting.
+                        // The author is telling us they want to complete.
+                        subscriber.complete()
+                      },
+                    )
+                    notifier.subscribe(notifierSubscriber)
+                  } else {
+                    // There was no notifier given. Just resub immediately.
+                    resub()
+                  }
+                } else {
+                  // We're past our maximum number of retries.
+                  // Just send along the error.
+                  subscriber.error(err)
+                }
+              },
+            ),
+          )
+          if (syncUnsub) {
+            innerSub.unsubscribe()
+            innerSub = null
+            subscribeForRetry()
+          }
+        }
+        subscribeForRetry()
+      })
+}

package/serializers.js

@@ -1,11 +1,12 @@
 import { SIGNALS } from './platform.js'
 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?.get?.(key) || obj.getHeader?.(key) || obj.headers?.[key]
+    : obj.headers?.[key] || obj.headers?.get?.(key) || obj.getHeader?.(key)
 }
 
 function getHeaders(obj) {
@@ -35,15 +36,15 @@ function getUrl(obj) {
 
   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 (typeof url === 'string' && url) {
-    return url
-  }
-
   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 || ''}`
@@ -81,6 +82,18 @@ function getTarget(obj) {
     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 })
+    } 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
@@ -104,15 +117,17 @@ export default {
     },
   req: (req) =>
     req && {
+      id: req.id || getHeader(req, 'request-id'),
       method: req.method,
-      headers: getHeaders(req),
       target: getTarget(req),
+      url: getUrl(req),
+      headers: getHeaders(req),
       timing: req.timing,
       bytesRead: req.bytesRead >= 0 ? req.bytesRead : undefined,
       bytesReadPerSecond:
         req.bytesReadPerSecond ??
-        (req.timing?.complete > 0 && req.bytesRead > 0
-          ? (req.bytesRead * 1e3) / req.timing.complete
+        (req.timing?.end > 0 && req.bytesRead > 0
+          ? (req.bytesRead * 1e3) / req.timing.end
           : undefined),
       remoteAddress: req.socket?.remoteAddress,
       remotePort: req.socket?.remotePort,
@@ -120,45 +135,45 @@ export default {
       closed: req.closed,
       destroyed: req.destroyed,
     },
+  ureq: (ureq) =>
+    ureq && {
+      id: ureq.id || getHeader(ureq, 'request-id'),
+      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'),
       headers: getHeaders(res),
       statusCode: res.statusCode || res.status,
       timing: res.timing,
       bytesWritten: res.bytesWritten >= 0 ? res.bytesWritten : undefined,
       bytesWrittenPerSecond:
         res.bytesWrittenPerSecond ??
-        (res.timing?.complete > 0 && res.bytesWritten > 0
-          ? (res.bytesWritten * 1e3) / res.timing.complete
+        (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,
     },
-  ureq: (ureq) =>
-    ureq && {
-      url: getUrl(ureq),
-      id: ureq.id || getHeader(ureq, 'request-id'),
-      userAgent: ureq.userAgent ?? getHeader(ureq, 'user-agent'),
-      timing: ureq.timing,
-      method: ureq.method,
-      body: typeof ureq.body === 'string' ? ureq.body : undefined,
-      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),
-      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: ures.timing,
+      headers: getHeaders(ures),
       statusCode: ures.statusCode ?? ures.status,
+      timing: ures.timing,
       bytesRead: ures.bytesRead,
       bytesReadPerSecond:
         ures.bytesReadPerSecond ??
@@ -166,7 +181,6 @@ export default {
           ? (ures.bytesRead * 1e3) / (ures.timing.end - ures.timing.data)
           : undefined),
       body: typeof ures.body === 'string' ? ures.body : undefined,
-      headers: getHeaders(ures),
     },
 }
 

package/util/compare-rev.js

@@ -214,14 +214,18 @@ export function compareRevSliceSlice(a, b) {
   let lenA = endA
   a = a.buffer
 
-  if (
-    !Buffer.isBuffer(a) ||
-    !Number.isInteger(idxA) ||
-    idxA < 0 ||
-    !Number.isInteger(lenA) ||
-    lenA < 0
-  ) {
-    throw new Error('invalid argument: a')
+  if (!Buffer.isBuffer(a)) {
+    throw Object.assign(new Error('a is not a Buffer.'), {
+      data: a?.constructor?.name,
+    })
+  }
+
+  if (!Number.isInteger(idxA) || idxA < 0) {
+    throw Object.assign(new Error('a has invalid index'), { data: idxA })
+  }
+
+  if (!Number.isInteger(lenA) || lenA < 0) {
+    throw Object.assign(new Error('a has invalid length'), { data: lenA })
   }
 
   const endB = b.byteOffset + b.byteLength
@@ -229,14 +233,18 @@ export function compareRevSliceSlice(a, b) {
   let lenB = endB
   b = b.buffer
 
-  if (
-    !Buffer.isBuffer(b) ||
-    !Number.isInteger(idxB) ||
-    idxB < 0 ||
-    !Number.isInteger(lenB) ||
-    lenB < 0
-  ) {
-    throw new Error('invalid argument: b')
+  if (!Buffer.isBuffer(b)) {
+    throw Object.assign(new Error('b is not a Buffer.'), {
+      data: b?.constructor?.name,
+    })
+  }
+
+  if (!Number.isInteger(idxB) || idxB < 0) {
+    throw Object.assign(new Error('b has invalid index'), { data: idxB })
+  }
+
+  if (!Number.isInteger(lenB) || lenB < 0) {
+    throw Object.assign(new Error('b has invalid length'), { data: lenB })
   }
 
   // Handle INF-XXXXXXXX