@nxtedition/lib 28.0.0 → 28.0.2

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/errors.js

@@ -102,17 +102,14 @@ function _serializeError(error, { depth }) {
   let {
     msg,
     message = msg,
-    errors,
     code,
     exitCode = Number(code),
     signal,
     signalCode = Number(signal),
-    cause,
     body,
     status,
     statusCode = status,
     headers,
-    aggregateErrors,
     ...properties
   } = error
 
@@ -144,12 +141,12 @@ function _serializeError(error, { depth }) {
     signalCode = SIGNALS[signalCode] ?? signalCode
   }
 
-  errors = [errors, aggregateErrors]
-    .flat()
+  const errors = [error.errors, error.aggregateErrors]
+    .flat(Infinity)
     .filter(Boolean)
     .flatMap((x) => _serializeError(x, { depth: depth + 1 }))
     .filter(Boolean)
-  cause = cause ? _serializeError(cause, { depth: depth + 1 }) : undefined
+  const cause = error.cause ? _serializeError(error.cause, { depth: depth + 1 }) : undefined
 
   delete error[kSeen]
 
@@ -160,14 +157,14 @@ function _serializeError(error, { depth }) {
           ...properties,
           message: message ?? 'Unknown error',
           type: type !== 'Object' ? type : undefined,
-          code: code ? `${code}` : undefined,
-          exitCode: exitCode ?? undefined,
-          signalCode: signalCode ?? undefined,
-          statusCode: statusCode ?? undefined,
-          headers: headers ?? undefined,
-          data: data ?? undefined,
-          cause: cause ?? undefined,
-          errors: fp.isEmpty(errors) ? undefined : undefined,
+          code: fp.isEmpty(code) ? undefined : `${code}`,
+          exitCode: fp.isEmpty(exitCode) ? undefined : exitCode,
+          signalCode: fp.isEmpty(signalCode) ? undefined : signalCode,
+          statusCode: fp.isEmpty(statusCode) ? undefined : statusCode,
+          headers: fp.isEmpty(headers) ? undefined : headers,
+          data: fp.isEmpty(data) ? undefined : data,
+          cause: fp.isEmpty(cause) ? undefined : cause,
+          errors: fp.isEmpty(errors) ? undefined : errors,
         },
         (k, v) => (typeof v === 'bigint' ? v.toString() : v),
       ),

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.0",
+  "version": "28.0.2",
   "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",
@@ -90,5 +91,5 @@
     "pino": ">=7.0.0",
     "rxjs": "^7.0.0"
   },
-  "gitHead": "dca4323e9bb3624bdce93ed05e654c8892074f7d"
+  "gitHead": "10cdafd06260ca5abfabbf08f503ccd78819c3e2"
 }

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,
@@ -191,7 +195,7 @@ export default {
 // Based on: https://github.com/pinojs/pino-std-serializers
 
 const seen = Symbol('circular-ref-tag')
-const rawSymbol = Symbol('pino-raw-err-ref')
+export const rawSymbol = Symbol('pino-raw-err-ref')
 
 const pinoErrProto = Object.create(
   {},
@@ -211,7 +215,7 @@ const pinoErrProto = Object.create(
       writable: true,
       value: undefined,
     },
-    aggregateErrors: {
+    errors: {
       enumerable: true,
       writable: true,
       value: undefined,
@@ -262,7 +266,7 @@ function errSerializer(err) {
   _err.stack = err.stack
 
   if (errors != null) {
-    _err.aggregateErrors = errors
+    _err.errors = errors
   }
 
   if (isErrorLike(err.cause) && !Object.prototype.hasOwnProperty.call(err.cause, seen)) {