Suspected memory leak issue

[seepine]

What version of Hono are you using?

4.11.3

What runtime/platform is your app running on? (with version if possible)

Bun v1.3.5

What steps can reproduce the bug?

Touch src/index.ts

import { Hono } from "hono";


const app = new Hono();

// test
const matrixMultiply = (size: number) => {
  const a = Array.from({ length: size }, () =>
    Array.from({ length: size }, () => Math.random())
  );
  const b = Array.from({ length: size }, () =>
    Array.from({ length: size }, () => Math.random())
  );
  const m = a.length,
    n = a[0].length,
    p = b[0].length;
  const result = Array.from({ length: m }, () => new Array(p).fill(0));
  for (let i = 0; i < m; i++) {
    for (let j = 0; j < p; j++) {
      for (let k = 0; k < n; k++) {
        result[i][j] += a[i][k] * b[k][j];
      }
    }
  }
  return result;
};

app.get("/dynamic/matrix", (c) => {
  const size = 200;
  const product = matrixMultiply(size);
  return c.json({
    result: `Matrix multiply (${size}x${size}) done. First element: ${product[0][0].toFixed(
      4
    )}`,
  });
});

const server = Bun.serve({
  port: 3000,
  fetch: app.fetch,
});

Build with docker

FROM oven/bun:alpine AS build
WORKDIR /work
COPY package.json bun.lock ./
RUN bun install
COPY ./src ./src
ENV NODE_ENV=production
RUN bun build \
	--compile \
	--minify-whitespace \
	--minify-syntax \
	--outfile app \
	src/index.ts

# Runtime
FROM alpine
RUN apk add --no-cache libstdc++
WORKDIR /work
COPY --from=build /work/app app
ENV NODE_ENV=production
EXPOSE 3000
ENTRYPOINT ["./app"]

And run docker build & docker run
test by wrk

wrk -c 500 -t 15s http://localhost:3000/dynamic/matrix

What is the expected behavior?

Memory usage can be released

What do you see instead?

Use docker stats with wrk

• init memory: 5.43MB
• max memory: 78.25MB
• after 5 min memory: 46.86MB
• after 30 min memory: 46.86MB

Additional information

No response

[seepine]

I try elysiajs the same code
src/index.ts

import { Elysia } from "elysia";

const matrixMultiply = (size: number) => {
  const a = Array.from({ length: size }, () =>
    Array.from({ length: size }, () => Math.random())
  );
  const b = Array.from({ length: size }, () =>
    Array.from({ length: size }, () => Math.random())
  );
  const m = a.length,
    n = a[0].length,
    p = b[0].length;
  const result = Array.from({ length: m }, () => new Array(p).fill(0));
  for (let i = 0; i < m; i++) {
    for (let j = 0; j < p; j++) {
      for (let k = 0; k < n; k++) {
        result[i][j] += a[i][k] * b[k][j];
      }
    }
  }
  return result;
};

const app = new Elysia()
  .get("/", () => "Hello Elysia")
  .get("/dynamic/matrix", (c) => {
    const size = 200;
    const product = matrixMultiply(size);
    return {
      result: `Matrix multiply (${size}x${size}) done. First element: ${product[0][0].toFixed(
        4
      )}`,
    };
  })
  .listen(3000);

And the same dockerfile and wrk, the result of docker stats with wrk

• init memory: 11.30MB
• max memory: 83.48MB
• after 5 min memory: 12.13MB
• after 30 min memory: 12.13MB

[destroyer22719]

I tried this in NodeJS, for smaller requests the memory usage goes down, but after the wrk command the memory usage isn't going down.

It was initially 28MB but now after a few minutes with no subsequent requests it's still stuck at 162MB.

Maybe because of the high initial request Hono is keeping the memory usage high in anticipation for more requests later?

[tshmieldev]

Could it be bun optimizing for speed? Perhaps try with --smol or using Bun.gc()

I will check it later today

[tshmieldev]

Ran this experiment, I believe this is normal behavior as with Bun.gc(true) the memory got reclaimed and my max usage was way lower, which means it's probably not actually leaking, just being lazy.

Load Test Details:

• Tool: k6
• Duration: 3 minutes
• Virtual Users: 50 concurrent
• Platform: macOS (M-series) & Docker (Alpine)

Memory usage outside docker was measured using a script, every second, using the ps command.

Scenario	Peak Memory	Final Memory (after cooldown)
Hono (Source)	~142 MB	~142 MB
Hono (Binary via bun build)	~132 MB	~132 MB
Pure Bun (No Framework)	~100 MB	~100 MB
Hono (Docker/Alpine)	~135 MB	~46 MB
Hono + Bun.gc(true)	~54 MB	~54 MB

I did this test once, so it may be worth trying on your machine to confirm.

[seepine]

I tried again and added golang comparison, it seems that there is an issue with the bun memory recycling mechanism.

Although it cannot be restored to its initial runtime, it has indeed decreased significantly compared to the last test.

framework	init memory	wrk max	wrk
go	2.73	9.5	9.48
hono	6.197	55.16	23.54
elysia	12.17	40	15.31