Bun 1.4 vs. Node.js 24: HTTP/3 Throughput for Real-Time Chat Applications

// Bun 1.4 HTTP/3 Real-Time Chat Server
// Requirements: Bun 1.4.0+, --experimental-quic flag not needed (native support)
import { serve } from "bun";

// Configuration for chat workload
const CHAT_PORT = 4433;
const QUIC_CERT = "./cert.pem"; // Let's Encrypt or self-signed cert
const QUIC_KEY = "./key.pem";
const MAX_CONNECTIONS = 150000; // Hard cap to prevent OOM
const CONNECTION_IDLE_TIMEOUT = 300000; // 5 minutes idle timeout

// In-memory store for active connections (for demo; use Redis in prod)
const activeConnections = new Map();
let connectionCounter = 0;

// Error handling for certificate loading
try {
  const cert = await Bun.file(QUIC_CERT).text();
  const key = await Bun.file(QUIC_KEY).text();
} catch (err) {
  console.error(`Failed to load TLS cert/key: ${err.message}`);
  process.exit(1);
}

const server = serve({
  port: CHAT_PORT,
  // Enable HTTP/3 (QUIC) support
  quic: {
    cert: QUIC_CERT,
    key: QUIC_KEY,
    maxConnections: MAX_CONNECTIONS,
    idleTimeout: CONNECTION_IDLE_TIMEOUT,
  },
  // Handle incoming HTTP/3 requests (both unary and streaming for chat)
  fetch(req) {
    const url = new URL(req.url);
    // Handle WebSocket-like bidirectional streaming over HTTP/3
    if (url.pathname === "/chat") {
      // Upgrade to bidirectional stream for real-time messaging
      const { socket, response } = Bun.upgradeWebSocket(req, {
        // On new connection
        onOpen(ws) {
          const connId = ++connectionCounter;
          activeConnections.set(connId, ws);
          console.log(`[Bun] New connection: ${connId}, total: ${activeConnections.size}`);
          ws.send(JSON.stringify({ type: "welcome", connId, activeUsers: activeConnections.size }));
          // Broadcast user joined to all connections
          broadcast(JSON.stringify({ type: "user-joined", connId, activeUsers: activeConnections.size }));
        },
        // On message received
        onMessage(ws, message) {
          try {
            const parsed = JSON.parse(message);
            if (parsed.type === "chat-message") {
              // Broadcast message to all active connections
              broadcast(JSON.stringify({
                type: "chat-message",
                senderId: parsed.senderId || "anonymous",
                content: parsed.content,
                timestamp: Date.now(),
              }));
            }
          } catch (err) {
            ws.send(JSON.stringify({ type: "error", message: "Invalid message format" }));
          }
        },
        // On connection close
        onClose(ws) {
          for (const [connId, conn] of activeConnections.entries()) {
            if (conn === ws) {
              activeConnections.delete(connId);
              console.log(`[Bun] Connection closed: ${connId}, total: ${activeConnections.size}`);
              broadcast(JSON.stringify({ type: "user-left", connId, activeUsers: activeConnections.size }));
              break;
            }
          }
        },
        // On error
        onError(ws, err) {
          console.error(`[Bun] WebSocket error: ${err.message}`);
        },
      });
      return response;
    }
    // Health check endpoint
    if (url.pathname === "/health") {
      return new Response(JSON.stringify({ status: "ok", activeConnections: activeConnections.size }), {
        headers: { "Content-Type": "application/json" },
      });
    }
    return new Response("Not found", { status: 404 });
  },
  // Global error handler
  error(error) {
    console.error(`[Bun] Server error: ${error.message}`);
    return new Response("Internal server error", { status: 500 });
  },
});

// Broadcast helper function
function broadcast(message) {
  for (const ws of activeConnections.values()) {
    try {
      ws.send(message);
    } catch (err) {
      console.error(`[Bun] Failed to broadcast to connection: ${err.message}`);
    }
  }
}

console.log(`[Bun] HTTP/3 Chat Server running on port ${CHAT_PORT} (QUIC enabled)`);

// Node.js 24 HTTP/3 Real-Time Chat Server
// Requirements: Node.js 24.0.0+, run with --experimental-http3 flag
// Install dependencies: npm install @nodejs/quic
const { createQuicSocket } = require("node:quic");
const { createServer } = require("node:http");
const { WebSocketServer } = require("ws"); // Fallback for HTTP/2, but we use QUIC
const fs = require("node:fs");
const path = require("node:path");

// Configuration
const CHAT_PORT = 4433;
const QUIC_CERT = path.join(__dirname, "cert.pem");
const QUIC_KEY = path.join(__dirname, "key.pem");
const MAX_CONNECTIONS = 100000; // Lower than Bun due to memory overhead
const CONNECTION_IDLE_TIMEOUT = 300000; // 5 minutes

// In-memory connection store (use Redis in prod)
const activeConnections = new Map();
let connectionCounter = 0;

// Load TLS certificates
let cert, key;
try {
  cert = fs.readFileSync(QUIC_CERT);
  key = fs.readFileSync(QUIC_KEY);
} catch (err) {
  console.error(`Failed to load TLS cert/key: ${err.message}`);
  process.exit(1);
}

// Create QUIC socket for HTTP/3
const quicSocket = createQuicSocket({
  address: "0.0.0.0",
  port: CHAT_PORT,
  maxConnections: MAX_CONNECTIONS,
  idleTimeout: CONNECTION_IDLE_TIMEOUT,
});

// Handle QUIC sessions (HTTP/3 connections)
quicSocket.on("session", (session) => {
  // Track session
  const sessionId = ++connectionCounter;
  activeConnections.set(sessionId, session);
  console.log(`[Node.js] New QUIC session: ${sessionId}, total: ${activeConnections.size}`);

  // Send welcome message
  session.write(JSON.stringify({
    type: "welcome",
    sessionId,
    activeUsers: activeConnections.size,
  }));

  // Broadcast user joined
  broadcast(JSON.stringify({
    type: "user-joined",
    sessionId,
    activeUsers: activeConnections.size,
  }));

  // Handle incoming data (chat messages)
  session.on("data", (chunk) => {
    try {
      const message = JSON.parse(chunk.toString());
      if (message.type === "chat-message") {
        broadcast(JSON.stringify({
          type: "chat-message",
          senderId: message.senderId || "anonymous",
          content: message.content,
          timestamp: Date.now(),
        }));
      }
    } catch (err) {
      session.write(JSON.stringify({ type: "error", message: "Invalid message format" }));
    }
  });

  // Handle session close
  session.on("close", () => {
    activeConnections.delete(sessionId);
    console.log(`[Node.js] Session closed: ${sessionId}, total: ${activeConnections.size}`);
    broadcast(JSON.stringify({
      type: "user-left",
      sessionId,
      activeUsers: activeConnections.size,
    }));
  });

  // Handle session errors
  session.on("error", (err) => {
    console.error(`[Node.js] QUIC session error: ${err.message}`);
  });
});

// Handle QUIC socket errors
quicSocket.on("error", (err) => {
  console.error(`[Node.js] QUIC socket error: ${err.message}`);
});

// Broadcast helper
function broadcast(message) {
  for (const session of activeConnections.values()) {
    try {
      session.write(message);
    } catch (err) {
      console.error(`[Node.js] Failed to broadcast: ${err.message}`);
    }
  }
}

// Health check endpoint via HTTP/3 (using node's experimental http3)
const http3Server = createServer({
  cert,
  key,
  quic: true,
});

http3Server.on("request", (req, res) => {
  if (req.url === "/health") {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ status: "ok", activeConnections: activeConnections.size }));
  } else {
    res.writeHead(404);
    res.end("Not found");
  }
});

http3Server.listen(CHAT_PORT, () => {
  console.log(`[Node.js] HTTP/3 Chat Server running on port ${CHAT_PORT} (experimental)`);
});

// HTTP/3 Chat Throughput Benchmark Script
// Tests Bun 1.4 vs Node.js 24 servers
// Requirements: Bun 1.4+ or Node.js 24+, hey modified for HTTP/3
import { spawn } from "node:child_process";
import fs from "node:fs";
import path from "node:path";

// Configuration
const BUN_SERVER_PATH = path.join(__dirname, "bun-chat-server.js");
const NODE_SERVER_PATH = path.join(__dirname, "node-chat-server.js");
const BENCH_RESULTS_PATH = path.join(__dirname, "bench-results.json");
const CONCURRENT_CONNECTIONS = [10000, 50000, 100000, 127000]; // Max for Bun
const TEST_DURATION = "30s"; // 30 seconds per test
const PAYLOAD_SIZE = 1024; // 1KB chat payload
const HEY_PATH = path.join(__dirname, "hey-http3"); // Modified hey binary

// Results store
const results = {
  bun: {},
  node: {},
  metadata: {
    timestamp: new Date().toISOString(),
    hardware: "AWS c7g.2xlarge (8 vCPU, 16GB RAM)",
    bunVersion: "1.4.0",
    nodeVersion: "24.0.0",
    payloadSize: PAYLOAD_SIZE,
  },
};

// Helper to start server process
function startServer(type) {
  return new Promise((resolve, reject) => {
    const serverPath = type === "bun" ? BUN_SERVER_PATH : NODE_SERVER_PATH;
    const cmd = type === "bun" ? "bun" : "node";
    const args = type === "node" ? ["--experimental-http3", serverPath] : [serverPath];
    const server = spawn(cmd, args, { stdio: "pipe" });
    let isReady = false;

    server.stdout.on("data", (data) => {
      if (data.toString().includes("running on port")) {
        isReady = true;
        resolve(server);
      }
    });

    server.stderr.on("data", (data) => {
      console.error(`[${type} server] Error: ${data}`);
    });

    server.on("error", (err) => {
      reject(new Error(`Failed to start ${type} server: ${err.message}`));
    });

    // Timeout if server doesn't start in 5s
    setTimeout(() => {
      if (!isReady) {
        server.kill();
        reject(new Error(`${type} server failed to start within 5s`));
      }
    }, 5000);
  });
}

// Helper to run hey benchmark
function runBenchmark(type, connections) {
  return new Promise((resolve, reject) => {
    const args = [
      "-n", connections.toString(),
      "-c", connections.toString(),
      "-d", TEST_DURATION,
      "-m", "GET",
      "-H", "Content-Type: application/json",
      `https://localhost:4433/chat`,
    ];
    const hey = spawn(HEY_PATH, args, { stdio: "pipe" });

    let output = "";
    hey.stdout.on("data", (data) => output += data.toString());
    hey.stderr.on("data", (data) => output += data.toString());

    hey.on("close", (code) => {
      if (code !== 0) {
        reject(new Error(`Hey benchmark failed with code ${code}: ${output}`));
        return;
      }
      // Parse hey output (simplified for demo)
      const requestsPerSecond = parseHeyOutput(output, "Requests/sec");
      const p99Latency = parseHeyOutput(output, "99%");
      resolve({ requestsPerSecond, p99Latency, rawOutput: output });
    });

    hey.on("error", (err) => {
      reject(new Error(`Failed to run hey: ${err.message}`));
    });
  });
}

// Simplified hey output parser (real implementation would parse more metrics)
function parseHeyOutput(output, metric) {
  const lines = output.split("\n");
  for (const line of lines) {
    if (line.includes(metric)) {
      return line.split(":")[1]?.trim() || "0";
    }
  }
  return "0";
}

// Main benchmark run
async function runAllBenchmarks() {
  for (const type of ["bun", "node"]) {
    console.log(`Starting ${type} server...`);
    let server;
    try {
      server = await startServer(type);
      results[type] = {};

      for (const conn of CONCURRENT_CONNECTIONS) {
        console.log(`Running ${type} benchmark with ${conn} connections...`);
        try {
          const benchResult = await runBenchmark(type, conn);
          results[type][conn] = benchResult;
          console.log(`Result: ${benchResult.requestsPerSecond} req/s, p99: ${benchResult.p99Latency}`);
        } catch (err) {
          console.error(`Benchmark failed for ${type} ${conn} connections: ${err.message}`);
          results[type][conn] = { error: err.message };
        }
      }
    } catch (err) {
      console.error(`Failed to run ${type} benchmarks: ${err.message}`);
    } finally {
      if (server) {
        server.kill();
        // Wait for server to shut down
        await new Promise(resolve => setTimeout(resolve, 1000));
      }
    }
  }

  // Save results to file
  fs.writeFileSync(BENCH_RESULTS_PATH, JSON.stringify(results, null, 2));
  console.log(`Benchmarks complete. Results saved to ${BENCH_RESULTS_PATH}`);
}

// Run benchmarks
runAllBenchmarks().catch(console.error);

const quicSocket = createQuicSocket({
  address: "0.0.0.0",
  port: 4433,
  migrateConnectionId: true, // Enable QUIC connection migration
  maxConnections: 100000,
});

// Reject payloads over 1KB
if (req.headers.get("content-length") > 1024) {
  return new Response(JSON.stringify({ error: "Payload too large" }), { status: 413 });
}

quicSocket.on("session", (session) => {
  session.on("handshake", (duration) => {
    console.log(`QUIC handshake completed in ${duration}ms`);
    // Send to metrics pipeline
    prometheusMetric.observe(duration);
  });
});