feat: enhance benchmarks with additional routes and middleware support

- Added new routes for plaintext, API responses, and settings in Gin, Hono, Mocket, Nitro, Node.js, PHP, and Spring Boot benchmarks.
- Implemented middleware for handling requests in Gin and Mocket frameworks.
- Introduced new endpoints for consuming requests and echoing JSON responses.
- Updated the run.py script to include new routes and improved route handling logic.
- Added performance tests for route matching and middleware execution in Mocket.
- Enhanced existing routes to support dynamic parameters and query handling.

Author: oboard

benchmarks/README.md

@@ -8,20 +8,45 @@ Routes:
 
 - `GET /plaintext` returns `Hello, World!`
 - `GET /api/plaintext` returns `Hello, World!` for middleware-focused Mocket runs
+- `GET /middleware/plaintext` exercises a real middleware stack where the target supports it
+- `GET /api/v1/users/current/profile/settings` exercises a deep static route
+- `GET /static/999` exercises lookup in a router with 1000 registered static routes
 - `GET /json` returns `{ "message": "Hello, World!" }`
 - `GET /echo/:name` returns the path parameter
+- `GET /users/:user_id/posts/:post_id/comments/:comment_id` exercises multiple path parameters
+- `GET /wild/**` returns the wildcard suffix
+- `GET /query?name=moonbit&repeat=4` exercises query-string routing
+- `GET /headers` mutates response headers
+- `GET /missing` exercises the 404 path
 - `POST /echo` echoes the request body
+- `POST /json-echo` echoes a JSON request body
+- `POST /consume` reads a 16 KiB request body and returns `ok`
+
+Route suites:
+
+- `quick`: `plaintext`, `json`, `echo`
+- `routing`: static, deep static, many-route static, dynamic, wildcard, query, and 404 paths
+- `body`: small text, JSON, and 16 KiB request-body echo
+- `middleware`: dedicated middleware route plus `/api` middleware-index route
+- `comprehensive`: broad GET and POST coverage for framework comparison
+- `all`: every route case, including middleware-specific cases
 
 Run a quick Mocket-only benchmark:
 
 ```sh
 python3 benchmarks/run.py --prepare mocket --duration 10 --connections 100
 ```
 
+Run the comprehensive Mocket suite:
+
+```sh
+python3 benchmarks/run.py --prepare mocket --suite comprehensive --duration 10 --connections 100
+```
+
 Run all configured targets:
 
 ```sh
-python3 benchmarks/run.py --prepare --duration 30 --connections 256
+python3 benchmarks/run.py --prepare --suite comprehensive --duration 30 --connections 256
 ```
 
 Run a subset:
@@ -30,10 +55,17 @@ Run a subset:
 python3 benchmarks/run.py --prepare mocket nodejs bun deno gin axum
 ```
 
-Run the middleware-index benchmark:
+Run the middleware benchmark. For Mocket, the runner starts the internal
+middleware profile and reports the result under the `mocket` target:
+
+```sh
+python3 benchmarks/run.py --prepare mocket --suite middleware --duration 10 --connections 100
+```
+
+Run the MoonBit in-process microbenchmarks:
 
 ```sh
-python3 benchmarks/run.py --prepare mocket-middleware --routes plaintext api_plaintext --duration 10 --connections 100
+moon bench --release --target native -p oboard/mocket -f performance_wbtest.mbt
 ```
 
 The runner uses `oha` when it is installed. If `oha` is not available, it falls

benchmarks/axum/src/main.rs

@@ -1,11 +1,14 @@
 use axum::{
     body::Bytes,
-    extract::Path,
+    extract::{Path, Query, Request},
+    http::HeaderMap,
+    middleware::{self, Next},
+    response::Response,
     routing::{get, post},
     Json, Router,
 };
 use serde::Serialize;
-use std::{env, net::SocketAddr};
+use std::{collections::HashMap, env, net::SocketAddr};
 
 #[derive(Serialize)]
 struct Payload {
@@ -22,23 +25,77 @@ async fn json() -> Json<Payload> {
     })
 }
 
+async fn query(Query(params): Query<HashMap<String, String>>) -> String {
+    params
+        .get("name")
+        .cloned()
+        .unwrap_or_else(|| "moonbit".to_string())
+}
+
 async fn echo_path(Path(name): Path<String>) -> String {
     name
 }
 
+async fn comment_path(
+    Path((_user_id, _post_id, comment_id)): Path<(String, String, String)>,
+) -> String {
+    comment_id
+}
+
+async fn wildcard(Path(path): Path<String>) -> String {
+    path
+}
+
+async fn headers() -> (HeaderMap, &'static str) {
+    let mut headers = HeaderMap::new();
+    headers.insert("x-benchmark", "axum".parse().unwrap());
+    headers.insert("content-type", "text/plain; charset=utf-8".parse().unwrap());
+    (headers, "ok")
+}
+
 async fn echo_body(body: Bytes) -> Bytes {
     body
 }
 
+async fn consume_body(body: Bytes) -> &'static str {
+    let _ = body.len();
+    "ok"
+}
+
+async fn noop_middleware(request: Request, next: Next) -> Response {
+    next.run(request).await
+}
+
 #[tokio::main]
 async fn main() {
     let port = env::var("PORT").unwrap_or_else(|_| "3000".to_string());
     let addr: SocketAddr = format!("0.0.0.0:{port}").parse().unwrap();
-    let app = Router::new()
+    let mut app = Router::new()
         .route("/plaintext", get(plaintext))
+        .route("/api/plaintext", get(plaintext))
+        .route(
+            "/middleware/plaintext",
+            get(plaintext).route_layer(middleware::from_fn(noop_middleware)),
+        )
+        .route(
+            "/api/v1/users/current/profile/settings",
+            get(|| async { "settings" }),
+        )
         .route("/json", get(json))
         .route("/echo/:name", get(echo_path))
-        .route("/echo", post(echo_body));
+        .route(
+            "/users/:user_id/posts/:post_id/comments/:comment_id",
+            get(comment_path),
+        )
+        .route("/wild/*path", get(wildcard))
+        .route("/query", get(query))
+        .route("/headers", get(headers))
+        .route("/echo", post(echo_body))
+        .route("/json-echo", post(echo_body))
+        .route("/consume", post(consume_body));
+    for i in 0..1000 {
+        app = app.route(&format!("/static/{i}"), get(plaintext));
+    }
 
     let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
     axum::serve(listener, app).await.unwrap();

benchmarks/bun/server.js

@@ -1,4 +1,5 @@
 const port = Number.parseInt(Bun.env.PORT ?? "3000", 10);
+const manyRoutes = new Set(Array.from({ length: 1000 }, (_, i) => `/static/${i}`));
 
 Bun.serve({
   hostname: "0.0.0.0",
@@ -12,6 +13,27 @@ Bun.serve({
       });
     }
 
+    if (request.method === "GET" && url.pathname === "/api/plaintext") {
+      return new Response("Hello, World!", {
+        headers: { "content-type": "text/plain; charset=utf-8" },
+      });
+    }
+
+    if (
+      request.method === "GET" &&
+      url.pathname === "/api/v1/users/current/profile/settings"
+    ) {
+      return new Response("settings", {
+        headers: { "content-type": "text/plain; charset=utf-8" },
+      });
+    }
+
+    if (request.method === "GET" && manyRoutes.has(url.pathname)) {
+      return new Response("Hello, World!", {
+        headers: { "content-type": "text/plain; charset=utf-8" },
+      });
+    }
+
     if (request.method === "GET" && url.pathname === "/json") {
       return Response.json({ message: "Hello, World!" });
     }
@@ -23,12 +45,56 @@ Bun.serve({
       );
     }
 
+    const multiParamMatch = url.pathname.match(
+      /^\/users\/([^/]+)\/posts\/([^/]+)\/comments\/([^/]+)$/,
+    );
+    if (request.method === "GET" && multiParamMatch) {
+      return new Response(decodeURIComponent(multiParamMatch[3]), {
+        headers: { "content-type": "text/plain; charset=utf-8" },
+      });
+    }
+
+    if (request.method === "GET" && url.pathname.startsWith("/wild/")) {
+      return new Response(
+        decodeURIComponent(url.pathname.slice("/wild/".length)),
+        { headers: { "content-type": "text/plain; charset=utf-8" } },
+      );
+    }
+
+    if (request.method === "GET" && url.pathname === "/query") {
+      return new Response(url.searchParams.get("name") || "moonbit", {
+        headers: { "content-type": "text/plain; charset=utf-8" },
+      });
+    }
+
+    if (request.method === "GET" && url.pathname === "/headers") {
+      return new Response("ok", {
+        headers: {
+          "content-type": "text/plain; charset=utf-8",
+          "x-benchmark": "bun",
+        },
+      });
+    }
+
     if (request.method === "POST" && url.pathname === "/echo") {
       return new Response(request.body, {
         headers: { "content-type": "application/octet-stream" },
       });
     }
 
+    if (request.method === "POST" && url.pathname === "/json-echo") {
+      return new Response(request.body, {
+        headers: { "content-type": "application/json; charset=utf-8" },
+      });
+    }
+
+    if (request.method === "POST" && url.pathname === "/consume") {
+      await request.arrayBuffer();
+      return new Response("ok", {
+        headers: { "content-type": "text/plain; charset=utf-8" },
+      });
+    }
+
     return new Response("Not Found", { status: 404 });
   },
 });

benchmarks/deno/server.ts

@@ -1,6 +1,7 @@
 const port = Number.parseInt(Deno.env.get("PORT") ?? "3000", 10);
+const manyRoutes = new Set(Array.from({ length: 1000 }, (_, i) => `/static/${i}`));
 
-Deno.serve({ hostname: "0.0.0.0", port }, (request) => {
+Deno.serve({ hostname: "0.0.0.0", port }, async (request) => {
   const url = new URL(request.url);
 
   if (request.method === "GET" && url.pathname === "/plaintext") {
@@ -9,6 +10,27 @@ Deno.serve({ hostname: "0.0.0.0", port }, (request) => {
     });
   }
 
+  if (request.method === "GET" && url.pathname === "/api/plaintext") {
+    return new Response("Hello, World!", {
+      headers: { "content-type": "text/plain; charset=utf-8" },
+    });
+  }
+
+  if (
+    request.method === "GET" &&
+    url.pathname === "/api/v1/users/current/profile/settings"
+  ) {
+    return new Response("settings", {
+      headers: { "content-type": "text/plain; charset=utf-8" },
+    });
+  }
+
+  if (request.method === "GET" && manyRoutes.has(url.pathname)) {
+    return new Response("Hello, World!", {
+      headers: { "content-type": "text/plain; charset=utf-8" },
+    });
+  }
+
   if (request.method === "GET" && url.pathname === "/json") {
     return Response.json({ message: "Hello, World!" });
   }
@@ -20,12 +42,58 @@ Deno.serve({ hostname: "0.0.0.0", port }, (request) => {
     );
   }
 
+  const multiParamMatch = url.pathname.match(
+    /^\/users\/([^/]+)\/posts\/([^/]+)\/comments\/([^/]+)$/,
+  );
+  if (request.method === "GET" && multiParamMatch) {
+    return new Response(decodeURIComponent(multiParamMatch[3]), {
+      headers: { "content-type": "text/plain; charset=utf-8" },
+    });
+  }
+
+  if (request.method === "GET" && url.pathname.startsWith("/wild/")) {
+    return new Response(
+      decodeURIComponent(url.pathname.slice("/wild/".length)),
+      { headers: { "content-type": "text/plain; charset=utf-8" } },
+    );
+  }
+
+  if (request.method === "GET" && url.pathname === "/query") {
+    return new Response(url.searchParams.get("name") || "moonbit", {
+      headers: { "content-type": "text/plain; charset=utf-8" },
+    });
+  }
+
+  if (request.method === "GET" && url.pathname === "/headers") {
+    return new Response("ok", {
+      headers: {
+        "content-type": "text/plain; charset=utf-8",
+        "x-benchmark": "deno",
+      },
+    });
+  }
+
   if (request.method === "POST" && url.pathname === "/echo") {
-    return new Response(request.body, {
+    const body = await request.arrayBuffer();
+    return new Response(body, {
       headers: { "content-type": "application/octet-stream" },
     });
   }
 
+  if (request.method === "POST" && url.pathname === "/json-echo") {
+    const body = await request.arrayBuffer();
+    return new Response(body, {
+      headers: { "content-type": "application/json; charset=utf-8" },
+    });
+  }
+
+  if (request.method === "POST" && url.pathname === "/consume") {
+    await request.arrayBuffer();
+    return new Response("ok", {
+      headers: { "content-type": "text/plain; charset=utf-8" },
+    });
+  }
+
   return new Response("Not Found", { status: 404 });
 });