@contrast/agent-bundle 5.41.0 → 5.45.1

package/node_modules/@contrast/reporter/node_modules/sonic-boom/index.js

@@ -7,15 +7,11 @@ const path = require('path')
 const sleep = require('atomic-sleep')
 
 const BUSY_WRITE_TIMEOUT = 100
-const kEmptyBuffer = Buffer.allocUnsafe(0)
 
 // 16 KB. Don't write more than docker buffer size.
 // https://github.com/moby/moby/blob/513ec73831269947d38a644c278ce3cac36783b2/daemon/logger/copier.go#L13
 const MAX_WRITE = 16 * 1024
 
-const kContentModeBuffer = 'buffer'
-const kContentModeUtf8 = 'utf8'
-
 function openFile (file, sonic) {
   sonic._opening = true
   sonic._writing = true
@@ -42,8 +38,6 @@ function openFile (file, sonic) {
       return
     }
 
-    const reopening = sonic._reopening
-
     sonic.fd = fd
     sonic.file = file
     sonic._reopening = false
@@ -56,15 +50,13 @@ function openFile (file, sonic) {
       sonic.emit('ready')
     }
 
-    if (sonic.destroyed) {
+    if (sonic._reopening) {
       return
     }
 
     // start
-    if ((!sonic._writing && sonic._len > sonic.minLength) || sonic._flushPending) {
-      sonic._actualWrite()
-    } else if (reopening) {
-      process.nextTick(() => sonic.emit('drain'))
+    if (!sonic._writing && sonic._len > sonic.minLength && !sonic.destroyed) {
+      actualWrite(sonic)
     }
   }
 
@@ -95,19 +87,18 @@ function SonicBoom (opts) {
     return new SonicBoom(opts)
   }
 
-  let { fd, dest, minLength, maxLength, maxWrite, sync, append = true, mkdir, retryEAGAIN, fsync, contentMode, mode } = opts || {}
+  let { fd, dest, minLength, maxLength, maxWrite, sync, append = true, mode, mkdir, retryEAGAIN, fsync } = opts || {}
 
   fd = fd || dest
 
+  this._bufs = []
   this._len = 0
   this.fd = -1
-  this._bufs = []
-  this._lens = []
   this._writing = false
+  this._writingBuf = ''
   this._ending = false
   this._reopening = false
   this._asyncDrainScheduled = false
-  this._flushPending = false
   this._hwm = Math.max(minLength || 0, 16387)
   this.file = null
   this.destroyed = false
@@ -115,35 +106,12 @@ function SonicBoom (opts) {
   this.maxLength = maxLength || 0
   this.maxWrite = maxWrite || MAX_WRITE
   this.sync = sync || false
-  this.writable = true
   this._fsync = fsync || false
   this.append = append || false
   this.mode = mode
   this.retryEAGAIN = retryEAGAIN || (() => true)
   this.mkdir = mkdir || false
 
-  let fsWriteSync
-  let fsWrite
-  if (contentMode === kContentModeBuffer) {
-    this._writingBuf = kEmptyBuffer
-    this.write = writeBuffer
-    this.flush = flushBuffer
-    this.flushSync = flushBufferSync
-    this._actualWrite = actualWriteBuffer
-    fsWriteSync = () => fs.writeSync(this.fd, this._writingBuf)
-    fsWrite = () => fs.write(this.fd, this._writingBuf, this.release)
-  } else if (contentMode === undefined || contentMode === kContentModeUtf8) {
-    this._writingBuf = ''
-    this.write = write
-    this.flush = flush
-    this.flushSync = flushSync
-    this._actualWrite = actualWrite
-    fsWriteSync = () => fs.writeSync(this.fd, this._writingBuf, 'utf8')
-    fsWrite = () => fs.write(this.fd, this._writingBuf, 'utf8', this.release)
-  } else {
-    throw new Error(`SonicBoom supports "${kContentModeUtf8}" and "${kContentModeBuffer}", but passed ${contentMode}`)
-  }
-
   if (typeof fd === 'number') {
     this.fd = fd
     process.nextTick(() => this.emit('ready'))
@@ -158,7 +126,7 @@ function SonicBoom (opts) {
 
   this.release = (err, n) => {
     if (err) {
-      if ((err.code === 'EAGAIN' || err.code === 'EBUSY') && this.retryEAGAIN(err, this._writingBuf.length, this._len - this._writingBuf.length)) {
+      if (err.code === 'EAGAIN' && this.retryEAGAIN(err, this._writingBuf.length, this._len - this._writingBuf.length)) {
         if (this.sync) {
           // This error code should not happen in sync mode, because it is
           // not using the underlining operating system asynchronous functions.
@@ -172,7 +140,9 @@ function SonicBoom (opts) {
           }
         } else {
           // Let's give the destination some time to process the chunk.
-          setTimeout(fsWrite, BUSY_WRITE_TIMEOUT)
+          setTimeout(() => {
+            fs.write(this.fd, this._writingBuf, 'utf8', this.release)
+          }, BUSY_WRITE_TIMEOUT)
         }
       } else {
         this._writing = false
@@ -183,23 +153,34 @@ function SonicBoom (opts) {
     }
 
     this.emit('write', n)
-    const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n)
-    this._len = releasedBufObj.len
-    this._writingBuf = releasedBufObj.writingBuf
+
+    this._len -= n
+    // In case of multi-byte characters, the length of the written buffer
+    // may be different from the length of the string. Let's make sure
+    // we do not have an accumulated string with a negative length.
+    // This also mean that ._len is not precise, but it's not a problem as some
+    // writes might be triggered earlier than ._minLength.
+    if (this._len < 0) {
+      this._len = 0
+    }
+
+    // TODO if we have a multi-byte character in the buffer, we need to
+    // n might not be the same as this._writingBuf.length, so we might loose
+    // characters here. The solution to this problem is to use a Buffer for _writingBuf.
+    this._writingBuf = this._writingBuf.slice(n)
 
     if (this._writingBuf.length) {
       if (!this.sync) {
-        fsWrite()
+        fs.write(this.fd, this._writingBuf, 'utf8', this.release)
         return
       }
 
       try {
         do {
-          const n = fsWriteSync()
-          const releasedBufObj = releaseWritingBuf(this._writingBuf, this._len, n)
-          this._len = releasedBufObj.len
-          this._writingBuf = releasedBufObj.writingBuf
-        } while (this._writingBuf.length)
+          const n = fs.writeSync(this.fd, this._writingBuf, 'utf8')
+          this._len -= n
+          this._writingBuf = this._writingBuf.slice(n)
+        } while (this._writingBuf)
       } catch (err) {
         this.release(err)
         return
@@ -216,10 +197,10 @@ function SonicBoom (opts) {
       this._reopening = false
       this.reopen()
     } else if (len > this.minLength) {
-      this._actualWrite()
+      actualWrite(this)
     } else if (this._ending) {
       if (len > 0) {
-        this._actualWrite()
+        actualWrite(this)
       } else {
         this._writing = false
         actualClose(this)
@@ -244,25 +225,6 @@ function SonicBoom (opts) {
   })
 }
 
-/**
- * Release the writingBuf after fs.write n bytes data
- * @param {string | Buffer} writingBuf - currently writing buffer, usually be instance._writingBuf.
- * @param {number} len - currently buffer length, usually be instance._len.
- * @param {number} n - number of bytes fs already written
- * @returns {{writingBuf: string | Buffer, len: number}} released writingBuf and length
- */
-function releaseWritingBuf (writingBuf, len, n) {
-  // if Buffer.byteLength is equal to n, that means writingBuf contains no multi-byte character
-  if (typeof writingBuf === 'string' && Buffer.byteLength(writingBuf) !== n) {
-    // Since the fs.write callback parameter `n` means how many bytes the passed of string
-    // We calculate the original string length for avoiding the multi-byte character issue
-    n = Buffer.from(writingBuf).subarray(0, n).toString().length
-  }
-  len = Math.max(len - n, 0)
-  writingBuf = writingBuf.slice(n)
-  return { writingBuf, len }
-}
-
 function emitDrain (sonic) {
   const hasListeners = sonic.listenerCount('drain') > 0
   if (!hasListeners) return
@@ -272,19 +234,7 @@ function emitDrain (sonic) {
 
 inherits(SonicBoom, EventEmitter)
 
-function mergeBuf (bufs, len) {
-  if (bufs.length === 0) {
-    return kEmptyBuffer
-  }
-
-  if (bufs.length === 1) {
-    return bufs[0]
-  }
-
-  return Buffer.concat(bufs, len)
-}
-
-function write (data) {
+SonicBoom.prototype.write = function (data) {
   if (this.destroyed) {
     throw new Error('SonicBoom destroyed')
   }
@@ -309,96 +259,18 @@ function write (data) {
   this._len = len
 
   if (!this._writing && this._len >= this.minLength) {
-    this._actualWrite()
+    actualWrite(this)
   }
 
   return this._len < this._hwm
 }
 
-function writeBuffer (data) {
+SonicBoom.prototype.flush = function () {
   if (this.destroyed) {
     throw new Error('SonicBoom destroyed')
   }
 
-  const len = this._len + data.length
-  const bufs = this._bufs
-  const lens = this._lens
-
-  if (this.maxLength && len > this.maxLength) {
-    this.emit('drop', data)
-    return this._len < this._hwm
-  }
-
-  if (
-    bufs.length === 0 ||
-    lens[lens.length - 1] + data.length > this.maxWrite
-  ) {
-    bufs.push([data])
-    lens.push(data.length)
-  } else {
-    bufs[bufs.length - 1].push(data)
-    lens[lens.length - 1] += data.length
-  }
-
-  this._len = len
-
-  if (!this._writing && this._len >= this.minLength) {
-    this._actualWrite()
-  }
-
-  return this._len < this._hwm
-}
-
-function callFlushCallbackOnDrain (cb) {
-  this._flushPending = true
-  const onDrain = () => {
-    // only if _fsync is false to avoid double fsync
-    if (!this._fsync) {
-      fs.fsync(this.fd, (err) => {
-        this._flushPending = false
-        cb(err)
-      })
-    } else {
-      this._flushPending = false
-      cb()
-    }
-    this.off('error', onError)
-  }
-  const onError = (err) => {
-    this._flushPending = false
-    cb(err)
-    this.off('drain', onDrain)
-  }
-
-  this.once('drain', onDrain)
-  this.once('error', onError)
-}
-
-function flush (cb) {
-  if (cb != null && typeof cb !== 'function') {
-    throw new Error('flush cb must be a function')
-  }
-
-  if (this.destroyed) {
-    const error = new Error('SonicBoom destroyed')
-    if (cb) {
-      cb(error)
-      return
-    }
-
-    throw error
-  }
-
-  if (this.minLength <= 0) {
-    cb?.()
-    return
-  }
-
-  if (cb) {
-    callFlushCallbackOnDrain.call(this, cb)
-  }
-
-  if (this._writing) {
+  if (this._writing || this.minLength <= 0) {
     return
   }
 
@@ -406,43 +278,7 @@ function flush (cb) {
     this._bufs.push('')
   }
 
-  this._actualWrite()
-}
-
-function flushBuffer (cb) {
-  if (cb != null && typeof cb !== 'function') {
-    throw new Error('flush cb must be a function')
-  }
-
-  if (this.destroyed) {
-    const error = new Error('SonicBoom destroyed')
-    if (cb) {
-      cb(error)
-      return
-    }
-
-    throw error
-  }
-
-  if (this.minLength <= 0) {
-    cb?.()
-    return
-  }
-
-  if (cb) {
-    callFlushCallbackOnDrain.call(this, cb)
-  }
-
-  if (this._writing) {
-    return
-  }
-
-  if (this._bufs.length === 0) {
-    this._bufs.push([])
-    this._lens.push(0)
-  }
-
-  this._actualWrite()
+  actualWrite(this)
 }
 
 SonicBoom.prototype.reopen = function (file) {
@@ -465,9 +301,6 @@ SonicBoom.prototype.reopen = function (file) {
     throw new Error('Unable to reopen a file descriptor, you must pass a file to SonicBoom')
   }
 
-  if (file) {
-    this.file = file
-  }
   this._reopening = true
 
   if (this._writing) {
@@ -485,7 +318,7 @@ SonicBoom.prototype.reopen = function (file) {
     }
   })
 
-  openFile(this.file, this)
+  openFile(file || this.file, this)
 }
 
 SonicBoom.prototype.end = function () {
@@ -511,13 +344,13 @@ SonicBoom.prototype.end = function () {
   }
 
   if (this._len > 0 && this.fd >= 0) {
-    this._actualWrite()
+    actualWrite(this)
   } else {
     actualClose(this)
   }
 }
 
-function flushSync () {
+SonicBoom.prototype.flushSync = function () {
   if (this.destroyed) {
     throw new Error('SonicBoom destroyed')
   }
@@ -531,66 +364,13 @@ function flushSync () {
     this._writingBuf = ''
   }
 
-  let buf = ''
-  while (this._bufs.length || buf) {
-    if (buf.length <= 0) {
-      buf = this._bufs[0]
-    }
-    try {
-      const n = fs.writeSync(this.fd, buf, 'utf8')
-      const releasedBufObj = releaseWritingBuf(buf, this._len, n)
-      buf = releasedBufObj.writingBuf
-      this._len = releasedBufObj.len
-      if (buf.length <= 0) {
-        this._bufs.shift()
-      }
-    } catch (err) {
-      const shouldRetry = err.code === 'EAGAIN' || err.code === 'EBUSY'
-      if (shouldRetry && !this.retryEAGAIN(err, buf.length, this._len - buf.length)) {
-        throw err
-      }
-
-      sleep(BUSY_WRITE_TIMEOUT)
-    }
-  }
-
-  try {
-    fs.fsyncSync(this.fd)
-  } catch {
-    // Skip the error. The fd might not support fsync.
-  }
-}
-
-function flushBufferSync () {
-  if (this.destroyed) {
-    throw new Error('SonicBoom destroyed')
-  }
-
-  if (this.fd < 0) {
-    throw new Error('sonic boom is not ready yet')
-  }
-
-  if (!this._writing && this._writingBuf.length > 0) {
-    this._bufs.unshift([this._writingBuf])
-    this._writingBuf = kEmptyBuffer
-  }
-
-  let buf = kEmptyBuffer
-  while (this._bufs.length || buf.length) {
-    if (buf.length <= 0) {
-      buf = mergeBuf(this._bufs[0], this._lens[0])
-    }
+  while (this._bufs.length) {
+    const buf = this._bufs[0]
     try {
-      const n = fs.writeSync(this.fd, buf)
-      buf = buf.subarray(n)
-      this._len = Math.max(this._len - n, 0)
-      if (buf.length <= 0) {
-        this._bufs.shift()
-        this._lens.shift()
-      }
+      this._len -= fs.writeSync(this.fd, buf, 'utf8')
+      this._bufs.shift()
     } catch (err) {
-      const shouldRetry = err.code === 'EAGAIN' || err.code === 'EBUSY'
-      if (shouldRetry && !this.retryEAGAIN(err, buf.length, this._len - buf.length)) {
+      if (err.code !== 'EAGAIN' || !this.retryEAGAIN(err, buf.length, this._len - buf.length)) {
         throw err
       }
 
@@ -606,37 +386,20 @@ SonicBoom.prototype.destroy = function () {
   actualClose(this)
 }
 
-function actualWrite () {
-  const release = this.release
-  this._writing = true
-  this._writingBuf = this._writingBuf || this._bufs.shift() || ''
-
-  if (this.sync) {
-    try {
-      const written = fs.writeSync(this.fd, this._writingBuf, 'utf8')
-      release(null, written)
-    } catch (err) {
-      release(err)
-    }
-  } else {
-    fs.write(this.fd, this._writingBuf, 'utf8', release)
-  }
-}
-
-function actualWriteBuffer () {
-  const release = this.release
-  this._writing = true
-  this._writingBuf = this._writingBuf.length ? this._writingBuf : mergeBuf(this._bufs.shift(), this._lens.shift())
+function actualWrite (sonic) {
+  const release = sonic.release
+  sonic._writing = true
+  sonic._writingBuf = sonic._writingBuf || sonic._bufs.shift() || ''
 
-  if (this.sync) {
+  if (sonic.sync) {
     try {
-      const written = fs.writeSync(this.fd, this._writingBuf)
+      const written = fs.writeSync(sonic.fd, sonic._writingBuf, 'utf8')
       release(null, written)
     } catch (err) {
       release(err)
     }
   } else {
-    fs.write(this.fd, this._writingBuf, release)
+    fs.write(sonic.fd, sonic._writingBuf, 'utf8', release)
   }
 }
 
@@ -648,18 +411,11 @@ function actualClose (sonic) {
 
   sonic.destroyed = true
   sonic._bufs = []
-  sonic._lens = []
-
-  fs.fsync(sonic.fd, closeWrapped)
 
-  function closeWrapped () {
-    // We skip errors in fsync
-
-    if (sonic.fd !== 1 && sonic.fd !== 2) {
-      fs.close(sonic.fd, done)
-    } else {
-      done()
-    }
+  if (sonic.fd !== 1 && sonic.fd !== 2) {
+    fs.close(sonic.fd, done)
+  } else {
+    setImmediate(done)
   }
 
   function done (err) {

package/node_modules/@contrast/reporter/node_modules/sonic-boom/package.json

@@ -1,13 +1,13 @@
 {
   "name": "sonic-boom",
-  "version": "3.8.1",
+  "version": "3.2.0",
   "description": "Extremely fast utf8 only stream implementation",
   "main": "index.js",
   "type": "commonjs",
   "types": "types/index.d.ts",
   "scripts": {
-    "test": "npm run test:types && standard && npm run test:unit",
-    "test:unit": "tap",
+    "test": "npm run test:types && standard && tap test.js",
+    "test:unit": "tap test.js",
     "test:types": "tsc && tsd && ts-node types/tests/test.ts",
     "prepare": "husky install"
   },
@@ -31,19 +31,24 @@
   },
   "homepage": "https://github.com/pinojs/sonic-boom#readme",
   "devDependencies": {
-    "@types/node": "^20.1.0",
+    "@types/node": "^18.0.0",
     "fastbench": "^1.0.1",
-    "husky": "^9.0.6",
+    "husky": "^8.0.1",
     "proxyquire": "^2.1.3",
     "standard": "^17.0.0",
     "tap": "^16.2.0",
-    "tsd": "^0.31.0",
-    "typescript": "^5.0.2",
+    "tsd": "^0.22.0",
+    "typescript": "^4.7.2",
     "ts-node": "^10.8.0"
   },
   "dependencies": {
     "atomic-sleep": "^1.0.0"
   },
+  "husky": {
+    "hooks": {
+      "pre-commit": "npm test"
+    }
+  },
   "tsd": {
     "directory": "./types"
   }