Memory leak

[FDiskas]

If I remove await from a request, memory usage is very high, this is normal. The garbage collector should clear this after some time. It looks like at some point it does, but memory usage still after the minute or so is huge.

Do you have any thoughts or ideas about this code or other ways to test bun for memory leaks?

Note I'm not good at async await stuff

MemUse 2889.719 mb (+51.281 mb) | heap 54.469 mb | heapCap 272.889 mb | extMem 20.076 mb | objs 1091.4k | reqs 77.4k
MemUse 2931.813 mb (+42.094 mb) | heap 26.382 mb | heapCap 253.683 mb | extMem 0.870 mb | objs 831.6k | reqs 72.9k
MemUse 3009.391 mb (+77.578 mb) | heap 44.226 mb | heapCap 268.792 mb | extMem 15.980 mb | objs 896.1k | reqs 85.0k
MemUse 3039.250 mb (+29.859 mb) | heap 23.718 mb | heapCap 255.497 mb | extMem 2.669 mb | objs 681.9k | reqs 85.3k
MemUse 3064.047 mb (+24.797 mb) | heap 17.597 mb | heapCap 253.022 mb | extMem 0.194 mb | objs 566.5k | reqs 90.4k
MemUse 3074.984 mb (+10.937 mb) | heap 20.216 mb | heapCap 257.064 mb | extMem 4.236 mb | objs 513.6k | reqs 90.3k
MemUse 3031.078 mb (-43.906 mb) | heap 14.134 mb | heapCap 254.152 mb | extMem 1.324 mb | objs 414.1k | reqs 71.8k
MemUse 3028.797 mb (-2.281 mb) | heap 15.102 mb | heapCap 256.513 mb | extMem 3.684 mb | objs 365.0k | reqs 71.8k
MemUse 3078.047 mb (+49.250 mb) | heap 39.101 mb | heapCap 275.960 mb | extMem 23.132 mb | objs 482.3k | reqs 72.4k
MemUse 3080.875 mb (+2.828 mb) | heap 18.595 mb | heapCap 262.372 mb | extMem 9.544 mb | objs 277.8k | reqs 71.9k
MemUse 3139.719 mb (+58.844 mb) | heap 31.877 mb | heapCap 273.956 mb | extMem 21.128 mb | objs 314.8k | reqs 74.4k
MemUse 3150.906 mb (+11.187 mb) | heap 38.684 mb | heapCap 280.659 mb | extMem 27.831 mb | objs 307.5k | reqs 72.3k
MemUse 3173.297 mb (+22.391 mb) | heap 4.305 mb | heapCap 255.798 mb | extMem 2.970 mb | objs 35.9k | reqs 29.2k

import { heapStats } from 'bun:jsc'

// Log Memory utils:
let lastMemoryLogAt = 0
let lastMemoryMb = 0
let lastReqs = 0
let reqs = 0
const logMemoryEverySeconds = (opt?: { force?: boolean }) => {
  reqs++
  const now = new Date().getTime()
  if (now - lastMemoryLogAt > 1000 || opt?.force) {
    const memoryMb = (process.memoryUsage.rss() / 1024 / 1024).toFixed(3)
    const stat = heapStats()
    const myStat = {
      heapSize: (stat.heapSize / 1024 / 1024).toFixed(3),
      heapCapacity: (stat.heapCapacity / 1024 / 1024).toFixed(3),
      extraMemorySize: (stat.extraMemorySize / 1024 / 1024).toFixed(3),
      objectCount: (stat.objectCount / 1000).toFixed(1),
    }
    const _reqsDelta = reqs - lastReqs
    const reqsDelta = _reqsDelta >= 1000 ? (_reqsDelta / 1000).toFixed(1) + 'k' : _reqsDelta
    const delta = +memoryMb - lastMemoryMb
    const plusSign = delta > 0 ? '+' : ''
    console.log(
      `MemUse ${memoryMb} mb (${plusSign}${delta.toFixed(3)} mb)` +
        ` | heap ${myStat.heapSize} mb | heapCap ${myStat.heapCapacity} mb` +
        ` | extMem ${myStat.extraMemorySize} mb | objs ${myStat.objectCount}k` +
        ` | reqs ${reqsDelta}`
    )
    lastMemoryLogAt = now
    lastMemoryMb = +memoryMb
    lastReqs = reqs
  }
}

//
// Test utils:
//
let startAt = new Date().getTime()
const hasPassedSeconds = (sec: number) => {
  const now = new Date().getTime()
  if (now - startAt < 1000 * sec) {
    return true
  } else {
    startAt = now

    return false
  }
}

//
// Start Bun server:
//
const bunPort = 3001
Bun.serve({
  fetch(req: Request) {
    logMemoryEverySeconds()

    return new Response('Ok')
  },
  port: bunPort,
})

//
// Tests 1:
//
console.log('\n (warming up) Test Bun.serve() test without body')
while (hasPassedSeconds(5)) {
  await fetch(`http://localhost:${bunPort}/test-post`, {
    method: 'POST',
    body: undefined,
  })
}
logMemoryEverySeconds({ force: true })

//
// Tests 2:
//
console.log('\n Test Bun.serve() test with body=1:')
while (hasPassedSeconds(20)) {
  // Do not await here, we want to stress the server
  fetch(`http://localhost:${bunPort}/test-post`, {
    method: 'POST',
    body: '1',
  })
}
logMemoryEverySeconds({ force: true })

//
// Tests 3:
//
console.log('\n Test Bun.serve() test without body')
while (hasPassedSeconds(5)) {
  await fetch(`http://localhost:${bunPort}/test-post`, {
    method: 'POST',
    body: undefined,
  })
}
logMemoryEverySeconds({ force: true })

console.log('\nTest Completed!')
process.exit(0)

[ericktolle787]

Hi guys, I found the problem.
Anyone who wants to use systeminformation in deno has to activate the --unstable-unsafe-proto flag,
because deno says that for security reasons "Deno made a conscious decision to not support Object.prototype.proto for security reasons. However there are still many npm packages that rely on this property to work correctly." Well, at least I can continue with the project I'm working on. I tested removing the

st.__proto__.toLowerCase = stringToLower;
st.__proto__.toString = stringToString;
st.__proto__.substr = stringSubstr;

and I didn't notice any difference in the functions, from I tested.
here in the problem documentation of deno https://docs.deno.com/runtime/reference/cli/unstable_flags/#--unstable-unsafe-proto