@nxtedition/lib 28.0.1 → 28.0.3

package/app.d.ts

@@ -46,6 +46,8 @@ export interface App<
     | Subscription
     | ((logger: Logger) => void)
     | ((logger: Logger) => Promise<void>)
+    | (() => void)
+    | (() => Promise<void>)
     | Disposable
     | AsyncDisposable
   >

package/app.js

@@ -41,6 +41,7 @@ import { isTimeBetween } from './time.js'
 import makeUnderPressure from './under-pressure.js'
 import { nice } from '@nxtedition/sched'
 import { setAffinity } from './numa.js'
+import { getContainerMemoryLimit, getContainerMemoryUsage } from './memory.js'
 
 /**
  * @param {object} appConfig
@@ -670,6 +671,8 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
               heapUsed: mem.heapUsed,
               external: mem.external,
               arrayBuffers: mem.arrayBuffers,
+              containerLimit: getContainerMemoryLimit(),
+              containerUsage: getContainerMemoryUsage(),
               totalHeapTotal: 0,
               totalHeapUsed: 0,
               totalExternal: 0,
@@ -776,16 +779,45 @@ export function makeApp(appConfig, onTerminateOrMeta, metaOrNull) {
             rx.repeatWhen((complete$) => complete$.pipe(rx.delay(10e3))),
           ),
           stats$.pipe(
-            rx.map(({ undici: stats }) => {
-              return stats
-                ? [
-                    {
-                      id: 'app:undici_upstream_sockets',
-                      level: stats.sockets > 8192 ? 50 : stats.sockets > 4096 ? 40 : 30,
-                      msg: `Undici: ${stats.sockets} upstream connected`,
-                    },
-                  ]
-                : []
+            rx.map(({ memory, heap, utilization, undici }) => {
+              const messages = []
+
+              if (memory?.containerLimit) {
+                const usagePercent = (memory.containerUsage / memory.containerLimit) * 100
+                messages.push({
+                  id: 'app:container_memory_usage',
+                  level: usagePercent > 90 ? 50 : usagePercent > 70 ? 40 : 30,
+                  msg: `Memory Usage: ${usagePercent.toFixed(2)}%`,
+                })
+              }
+
+              if (heap) {
+                const usagePercent = (heap.used_heap_size / heap.heap_size_limit) * 100
+                messages.push({
+                  id: 'app:heap_memory_usage',
+                  level: usagePercent > 90 ? 50 : usagePercent > 70 ? 40 : 30,
+                  msg: `Heap Usage: ${usagePercent.toFixed(2)}%`,
+                })
+              }
+
+              if (utilization) {
+                const elp = utilization.utilization * 100
+                messages.push({
+                  id: 'app:event_loop_utilization',
+                  level: elp > 95 ? 50 : elp > 80 ? 40 : 30,
+                  msg: `Event Loop Utilization: ${elp.toFixed(2)}%`,
+                })
+              }
+
+              if (undici) {
+                messages.push({
+                  id: 'app:undici_upstream_sockets',
+                  level: undici.sockets > 8192 ? 50 : undici.sockets > 4096 ? 40 : 30,
+                  msg: `Undici: ${undici.sockets} upstream connected`,
+                })
+              }
+
+              return messages
             }),
           ),
           toobusy?.appLag$.pipe(

package/logger.js

@@ -1,16 +1,15 @@
-import assert from 'node:assert'
 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 = null, ...options } = {},
-  onTerminate,
-) {
-  assert(!onTerminate)
-
+export function createLogger({
+  level = isProduction ? 'debug' : 'trace',
+  flushInterval = 1e3,
+  stream,
+  ...options
+} = {}) {
   if (!stream) {
     if (
       process.stdout.write !== process.stdout.constructor.prototype.write ||
@@ -23,15 +22,24 @@ export function createLogger(
   if (stream) {
     // Do nothing...
   } else if (!isProduction) {
-    stream = pino.destination({ fd: process.stdout.fd ?? 1, sync: true })
+    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 })
+    stream = pino.destination({ fd: 1, sync: true, fsync: false })
   } else {
-    stream = pino.destination({ sync: false, minLength: 4 * 1024, maxWrite: 32 * 1024 })
+    stream = pino.destination({
+      sync: false,
+      fsync: false,
+      minLength: 4 * 1024,
+      maxWrite: 32 * 1024,
+    })
 
     let flushing = 0
-    setInterval(() => {
+    const onFlush = () => {
+      flushing--
+    }
+
+    const flushTimeout = setInterval(() => {
       if (flushing >= 10) {
         try {
           logger.warn('logger is flushing too slow')
@@ -41,10 +49,9 @@ export function createLogger(
         }
       } else {
         flushing++
-        stream.flush(() => {
-          flushing--
-        })
+        stream.flush(onFlush)
       }
+      flushTimeout.refresh()
     }, flushInterval).unref()
   }
 

package/memory.js

@@ -0,0 +1,43 @@
+import { readFileSync } from 'node:fs'
+
+function readFile(path) {
+  try {
+    return readFileSync(path, 'utf8').trim()
+  } catch {
+    return null
+  }
+}
+
+export function getContainerMemoryLimit() {
+  // cgroups v2
+  const v2Limit = readFile('/sys/fs/cgroup/memory.max')
+  if (v2Limit) {
+    return v2Limit === 'max' ? null : Number(v2Limit)
+  }
+
+  // cgroups v1
+  const v1Limit = readFile('/sys/fs/cgroup/memory/memory.limit_in_bytes')
+  if (v1Limit) {
+    const limit = Number(v1Limit)
+    // Very large number usually means "no limit"
+    return limit > 1e15 ? null : limit
+  }
+
+  return undefined
+}
+
+export function getContainerMemoryUsage() {
+  // cgroups v2
+  const v2Usage = readFile('/sys/fs/cgroup/memory.current')
+  if (v2Usage) {
+    return Number(v2Usage)
+  }
+
+  // cgroups v1
+  const v1Usage = readFile('/sys/fs/cgroup/memory/memory.usage_in_bytes')
+  if (v1Usage) {
+    return Number(v1Usage)
+  }
+
+  return undefined
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nxtedition/lib",
-  "version": "28.0.1",
+  "version": "28.0.3",
   "license": "UNLICENSED",
   "author": "Robert Nagy <robert.nagy@boffins.se>",
   "type": "module",
@@ -24,6 +24,7 @@
     "shared.js",
     "logger.js",
     "logger.d.ts",
+    "memory.js",
     "mime.js",
     "numa.js",
     "proxy.js",
@@ -36,6 +37,7 @@
     "errors.js",
     "errors.d.ts",
     "worker.js",
+    "slice.js",
     "stream.js",
     "transcript.js",
     "docker-secrets.js",
@@ -90,5 +92,5 @@
     "pino": ">=7.0.0",
     "rxjs": "^7.0.0"
   },
-  "gitHead": "2d70510dc7bad9dc43cf36884a293948bc23a6a6"
+  "gitHead": "15f4fd00f86a558ae56672b1efa3e909b23feb3f"
 }

package/serializers.js

@@ -118,6 +118,7 @@ export default {
   req: (req) =>
     req && {
       id: req.id || getHeader(req, 'request-id'),
+      httpVersion: req.httpVersion,
       method: req.method,
       target: getTarget(req),
       url: getUrl(req),
@@ -138,6 +139,7 @@ export default {
   ureq: (ureq) =>
     ureq && {
       id: ureq.id || getHeader(ureq, 'request-id'),
+      httpVersion: ureq.httpVersion,
       method: ureq.method,
       target: getTarget(ureq),
       url: getUrl(ureq),
@@ -154,6 +156,7 @@ export default {
   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,
@@ -171,6 +174,7 @@ export default {
   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,

package/slice.js

@@ -0,0 +1,278 @@
+import util from 'node:util'
+
+const EMPTY_BUF = Buffer.alloc(0)
+const POOL = []
+
+export class Slice {
+  buffer
+  byteOffset = 0
+  byteLength = 0
+  maxByteLength = 0
+
+  static EMPTY_BUF = EMPTY_BUF
+
+  /**
+   *
+   * @param {Buffer} [buffer]
+   * @param {number} [byteOffset]
+   * @param {number} [byteLength]
+   * @param {number} [maxByteLength]
+   */
+  constructor(
+    buffer = Slice.EMPTY_BUF,
+    byteOffset = 0,
+    byteLength = buffer.byteLength,
+    maxByteLength = byteLength,
+  ) {
+    if (byteOffset < 0 || !Number.isInteger(byteOffset)) {
+      throw new RangeError(`Invalid byteOffset: ${byteOffset}`)
+    }
+
+    if (byteLength < 0 || !Number.isInteger(byteLength)) {
+      throw new RangeError(`Invalid byteLength: ${byteLength}`)
+    }
+
+    if (
+      maxByteLength < byteLength ||
+      maxByteLength > buffer.byteLength ||
+      !Number.isInteger(maxByteLength)
+    ) {
+      throw new RangeError(`Invalid maxByteLength: ${maxByteLength}`)
+    }
+
+    this.buffer = buffer
+    this.byteOffset = byteOffset
+    this.byteLength = byteLength
+    this.maxByteLength = maxByteLength
+  }
+
+  static create(buffer, byteOffset, byteLength, maxByteLength) {
+    if (buffer === undefined) {
+      buffer = Slice.EMPTY_BUF
+    }
+    if (byteOffset === undefined) {
+      byteOffset = 0
+    }
+    if (byteLength === undefined) {
+      byteLength = buffer.byteLength
+    }
+    if (maxByteLength === undefined) {
+      maxByteLength = byteLength
+    }
+
+    const slice = POOL.pop()
+
+    if (slice) {
+      slice.buffer = buffer
+      slice.byteOffset = byteOffset
+      slice.byteLength = byteLength
+      slice.maxByteLength = maxByteLength
+      return slice
+    }
+
+    return new Slice(buffer, byteOffset, byteLength, maxByteLength)
+  }
+
+  static free(slice) {
+    if (slice == null) {
+      return
+    }
+
+    slice.reset()
+
+    if (POOL.length < 16 * 1024) {
+      POOL.push(slice)
+    }
+  }
+
+  reset() {
+    this.buffer = Slice.EMPTY_BUF
+    this.byteOffset = 0
+    this.byteLength = 0
+    this.maxByteLength = 0
+  }
+
+  get length() {
+    return this.byteLength
+  }
+
+  /**
+   * @param {Buffer|Slice} target
+   * @param {number} [targetStart = 0]
+   * @param {number} [sourceStart = 0]
+   * @param {number} [sourceEnd = this.byteOffset]
+   * @returns {number} Number of bytes written.
+   */
+  copy(target, targetStart, sourceStart, sourceEnd) {
+    if (target instanceof Slice) {
+      if (targetStart === undefined) {
+        targetStart = target.byteOffset
+      } else {
+        targetStart += target.byteOffset
+      }
+
+      target = target.buffer
+    }
+
+    if (sourceStart === undefined) {
+      sourceStart = this.byteOffset
+    } else {
+      sourceStart += this.byteOffset
+    }
+
+    if (sourceEnd === undefined) {
+      sourceEnd = this.byteLength + this.byteOffset
+    } else {
+      sourceEnd += this.byteOffset
+    }
+
+    return this.buffer.copy(target, targetStart, sourceStart, sourceEnd)
+  }
+
+  /**
+   * @param {Buffer|Slice} target
+   * @param {number} [targetStart = 0]
+   * @param {number} [targetEnd = target.byteOffset]
+   * @param {number} [sourceStart = 0]
+   * @param {number} [sourceEnd = this.byteOffset]
+   * @returns
+   */
+  compare(target, targetStart, targetEnd, sourceStart, sourceEnd) {
+    if (target instanceof Slice) {
+      if (targetStart === undefined) {
+        targetStart = target.byteOffset
+      } else {
+        targetStart += target.byteOffset
+      }
+
+      if (targetEnd === undefined) {
+        targetEnd = target.byteLength + target.byteOffset
+      } else {
+        targetEnd += target.byteOffset
+      }
+
+      target = target.buffer
+    }
+
+    if (sourceStart === undefined) {
+      sourceStart = this.byteOffset
+    } else {
+      sourceStart += this.byteOffset
+    }
+
+    if (sourceEnd === undefined) {
+      sourceEnd = this.byteLength + this.byteOffset
+    } else {
+      sourceEnd += this.byteOffset
+    }
+
+    return this.buffer.compare(target, targetStart, targetEnd, sourceStart, sourceEnd)
+  }
+
+  /**
+   *
+   * @param {string} string
+   * @param {number} [offset=0]
+   * @param {number} [length=this.byteLength - offset]
+   * @param {NodeJS.BufferEncoding} [encoding='utf8']
+   * @returns {number} Number of bytes written.
+   */
+  write(string, offset, length, encoding) {
+    if (offset === undefined) {
+      offset = this.byteOffset
+    } else {
+      offset += this.byteOffset
+    }
+
+    if (length === undefined) {
+      length = this.byteLength + this.byteOffset - offset
+    }
+
+    return this.buffer.write(string, offset, length, encoding)
+  }
+
+  set(array, offset) {
+    if (array == null) {
+      return
+    }
+
+    if (offset === undefined) {
+      offset = this.byteOffset
+    } else {
+      offset += this.byteOffset
+    }
+
+    array?.copy(this.buffer, offset)
+  }
+
+  at(index) {
+    return index >= 0
+      ? this.buffer[this.byteOffset + index]
+      : this.buffer[this.byteOffset + this.byteLength + index]
+  }
+
+  test(expr) {
+    return expr.test(this.buffer, this.byteOffset, this.byteLength)
+  }
+
+  readBigUInt64BE(offset = 0) {
+    if (offset === undefined) {
+      offset = this.byteOffset
+    } else {
+      offset += this.byteOffset
+    }
+
+    return this.buffer.readBigUInt64BE(offset)
+  }
+
+  /**
+   *
+   * @param {BufferEncoding} [encoding='utf8']
+   * @param {number} [start=0]
+   * @param {number} [end=this.byteLength]
+   * @returns {string}
+   */
+  toString(encoding, start, end) {
+    if (start === undefined) {
+      start = this.byteOffset
+    } else {
+      start += this.byteOffset
+    }
+
+    if (end === undefined) {
+      end = this.byteLength + this.byteOffset
+    } else {
+      end += this.byteOffset
+    }
+
+    return this.buffer.toString(encoding, start, end)
+  }
+
+  toBuffer(start, end) {
+    if (start === undefined) {
+      start = this.byteOffset
+    } else {
+      start += this.byteOffset
+    }
+
+    if (end === undefined) {
+      end = this.byteLength + this.byteOffset
+    } else {
+      end += this.byteOffset
+    }
+
+    return this.buffer.subarray(start, end)
+  }
+
+  [Symbol.toStringTag]() {
+    return this.toString()
+  }
+
+  [util.inspect.custom](depth, options, inspect) {
+    const bytes = []
+    for (let i = 0; i < this.byteLength; i++) {
+      bytes.push(this.buffer[this.byteOffset + i].toString(16).padStart(2, '0'))
+    }
+    return `Slice: "${this.toString()}" <${bytes.join(' ')}>`
+  }
+}