Exception Handling and Alerts

🚨 Introduction to Exception Handling and Alerts in Bun

In modern web applications, errors are inevitable. What separates a resilient app from a broken one is how it handles these errors. Bun, being a high-speed JavaScript runtime, offers flexibility in exception handling, and when combined with proper alerting mechanisms, it can make your app bulletproof. In this post, we’ll cover how to handle exceptions gracefully and trigger alerts when things go wrong in your Bun applications.

🧯 Basic Error Handling with try...catch

Let’s start with the basics. You can handle synchronous and asynchronous errors using try...catch blocks in Bun, just like in Node.js:

try {
  const data = await fetch("https://api.example.com/data");
  const json = await data.json();
  console.log(json);
} catch (error) {
  console.error("❌ Fetch failed:", error);
}

Always wrap risky operations like network requests, file reads, and JSON parsing in a try...catch block to prevent your app from crashing unexpectedly.

🛠️ Create a Centralized Error Handler

To keep your code DRY and manageable, you can create a centralized error handling function:

function handleError(error, context = "Unknown") {
  console.error(`🚨 Error in ${context}:`, error.message);
  // Optionally log to external service here
}

Use this handler across your app to standardize logging and ensure consistency in how errors are captured.

📬 Return Proper HTTP Error Responses

In Bun HTTP servers, make sure to return meaningful HTTP status codes when errors occur:

const server = Bun.serve({
  fetch(req) {
    try {
      // some logic
      throw new Error("Something went wrong");
    } catch (err) {
      return new Response(JSON.stringify({ error: err.message }), {
        status: 500,
        headers: { "Content-Type": "application/json" },
      });
    }
  },
});

This helps frontend applications handle errors gracefully based on status codes.

🔔 Setting Up Alerts with Email or Webhooks

When a critical exception occurs, it’s helpful to notify developers immediately. You can use services like Slack, Discord, or email via webhooks. Here’s an example of sending a simple alert using a POST request:

async function sendAlert(message) {
  await fetch("https://hooks.slack.com/services/your/webhook/url", {
    method: "POST",
    body: JSON.stringify({ text: `🚨 Bun App Alert: ${message}` }),
    headers: {
      "Content-Type": "application/json",
    },
  });
}

Call sendAlert() inside your error handler when needed.

📉 Logging Errors to a File

In production, logging to the console isn’t enough. You can log errors to a file using Bun’s file system support:

async function logErrorToFile(error) {
  const log = `[${new Date().toISOString()}] ${error.stack}\n`;
  await Bun.write("error.log", log, { append: true });
}

Combine this with your global handler to keep long-term logs for auditing or debugging purposes.

🧪 Handling Unhandled Rejections & Exceptions

Don’t forget to catch uncaught exceptions and unhandled promise rejections at the process level:

process.on("uncaughtException", (err) => {
  handleError(err, "Uncaught Exception");
});

process.on("unhandledRejection", (reason) => {
  handleError(reason, "Unhandled Rejection");
});

This ensures no error goes unnoticed and your app doesn’t crash silently.

📊 Integrating Monitoring Tools

For larger applications, consider integrating with observability tools like Sentry, LogRocket, or Prometheus. They offer dashboards, error tracking, and alert rules that give deeper insights into production performance and issues.

✅ Final Thoughts

Robust error handling and real-time alerts aren’t just nice-to-haves — they’re critical for maintaining uptime, user trust, and development sanity. With Bun’s flexibility and speed, implementing exception handling and alerts is straightforward and scalable. Whether you're building a small API or a full-scale app, prioritize graceful failure and visibility from day one.