@nxtedition/lib 23.17.0 → 23.17.2

package/package.json

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

package/trace.js

@@ -61,40 +61,29 @@ export function makeTrace({
         dispatcher: client,
       }).then(({ body }) => body.dump())
     } catch (err) {
-      logger.error({ err }, 'trace failed')
+      logger.error({ err, data }, 'trace failed')
     } finally {
       pending -= data.length
     }
   }
 
+  let dropCount = 0
   const warnDrop = fp.throttle(10e3, () => {
-    logger.warn('trace dropped')
+    logger.warn({ count: dropCount }, 'trace dropped')
+    dropCount = 0
   })
 
-  const prefix = `{ "create": { "_index": "trace-${index}" } }\n{ "serviceName": "${serviceName}", "op": "`
+  const prefix = `{"create":{"_index":"trace-${index}"}}\n{`
 
   function trace(obj, op) {
-    if (typeof obj === 'string') {
-      // Do nothing...
-    } else {
-      if (obj.serviceName) {
-        throw new Error('invalid property `serviceName`')
-      }
-      if (obj.op) {
-        throw new Error('invalid property `op`')
-      }
-      if (obj['@timestamp']) {
-        throw new Error('invalid property `@timestamp`')
-      }
-    }
-
     if (pending > limit) {
+      dropCount++
       warnDrop()
     } else {
       const doc = (typeof obj === 'string' ? obj : stringify(obj)).slice(1, -1)
       traceData +=
         prefix +
-        `${op}", "pid": ${process.pid}, "tid": ${threadId}, "traceId": ${genTraceId()}, "@timestamp": ${Date.now()}, ${doc} }\n`
+        `${doc},"serviceName":"${serviceName}","op":"${op}","pid":${process.pid},"tid":${threadId},"traceId":${genTraceId()},"@timestamp":${Date.now()}}\n`
       if (traceData.length > batch) {
         flushTraces()
       }

package/yield.js

@@ -1,12 +1,6 @@
 import { FixedQueue } from './fixed-queue.js'
 
-const yieldQueues = [new FixedQueue(), new FixedQueue(), new FixedQueue()]
-const yieldQueueLength = yieldQueues.length
-
-export const PRIORITY_HIGH = 0
-export const PRIORITY_NORMAL = 1
-export const PRIORITY_LOW = 2
-
+const yieldQueue = new FixedQueue()
 const yieldSchedule = globalThis.setImmediate ?? ((fn) => setTimeout(fn, 0))
 
 let yieldTimeout = 40
@@ -28,13 +22,13 @@ export function shouldYield() {
   return yieldActive
 }
 
-export function maybeYield(callback, priority) {
+export function maybeYield(callback) {
   if (callback != null && typeof callback !== 'function') {
     throw new TypeError('callback must be a function')
   }
 
   if (shouldYield()) {
-    return doYield(callback, priority)
+    return doYield(callback)
   }
 
   if (callback != null) {
@@ -44,39 +38,23 @@ export function maybeYield(callback, priority) {
   return null
 }
 
-export function doYield(callbackOrPriority, priorityOrNil) {
-  let callback = callbackOrPriority
-  let priority = priorityOrNil
-
-  if (callbackOrPriority == null) {
-    // Do nothing...
-  } else if (typeof callbackOrPriority === 'number' && priorityOrNil == null) {
-    priority = callbackOrPriority
-    callback = null
-  } else {
-    callback = callbackOrPriority
-  }
-
+export function doYield(callback) {
   if (callback != null && typeof callback !== 'function') {
     throw new TypeError('callback must be a function')
   }
 
-  if (priority != null && typeof priority !== 'number') {
-    throw new TypeError('priority must be a number')
-  }
-
   if (!yieldScheduled) {
     yieldScheduled = true
     yieldSchedule(dispatchYield)
   }
 
   if (callback != null) {
-    yieldQueues[priority ?? PRIORITY_NORMAL].push(callback)
+    yieldQueue.push(callback)
     return null
   }
 
   return new Promise((resolve) => {
-    yieldQueues[priority ?? PRIORITY_NORMAL].push(resolve)
+    yieldQueue.push(resolve)
   })
 }
 
@@ -84,17 +62,14 @@ function dispatchYield() {
   yieldTime = performance.now()
   yieldActive = false
 
-  for (let n = 0; n < yieldQueueLength; n++) {
-    const yieldQueue = yieldQueues[n]
-    while (!yieldQueue.isEmpty()) {
-      const resolve = yieldQueue.shift()
+  while (!yieldQueue.isEmpty()) {
+    const resolve = yieldQueue.shift()
 
-      resolve(null)
+    resolve(null)
 
-      if (shouldYield()) {
-        yieldSchedule(dispatchYield)
-        return
-      }
+    if (shouldYield()) {
+      yieldSchedule(dispatchYield)
+      return
     }
   }