Create http errors plugin

bin/local-test-util

@@ -121,7 +121,7 @@ async function buildNotifiers (notifier) {
 async function packNotifiers (notifier) {
   const notifiers = notifier
     ? [ notifier ]
-    : [ 'js', 'browser', 'node', 'web-worker', 'plugin-angular', 'plugin-react', 'plugin-vue' ]
+    : [ 'js', 'browser', 'node', 'web-worker', 'plugin-angular', 'plugin-react', 'plugin-vue', 'plugin-http-errors' ]
   for (const n of notifiers) {
     let packageLocation = `packages/${n}/`
     if (n === 'plugin-angular') packageLocation += 'dist/'
@@ -131,7 +131,7 @@ async function packNotifiers (notifier) {
 
 async function installNotifiers (notifier) {
   trace('install notifiers')
-  if (notifier && ![ 'browser', 'plugin-vue', 'plugin-react', 'web-worker' ].includes(notifier)) return
+  if (notifier && ![ 'browser', 'plugin-vue', 'plugin-react', 'web-worker', 'plugin-http-errors' ].includes(notifier)) return
   await ex(`npm`, [
     `install`,
     `--no-package-lock`,
@@ -144,7 +144,8 @@ async function installNotifiers (notifier) {
       `../../../../bugsnag-browser-${require('../packages/browser/package.json').version}.tgz`,
       `../../../../bugsnag-web-worker-${require('../packages/web-worker/package.json').version}.tgz`,
       `../../../../bugsnag-plugin-react-${require('../packages/plugin-react/package.json').version}.tgz`,
-      `../../../../bugsnag-plugin-vue-${require('../packages/plugin-vue/package.json').version}.tgz`
+      `../../../../bugsnag-plugin-vue-${require('../packages/plugin-vue/package.json').version}.tgz`,
+      `../../../../bugsnag-plugin-http-errors-${require('../packages/plugin-http-errors/package.json').version}.tgz`
     ]
   ), {
     cwd: `${__dirname}/../test/browser/features/fixtures`

jest.config.js

@@ -50,7 +50,8 @@ module.exports = {
       'plugin-inline-script-content',
       'plugin-simple-throttle',
       'plugin-console-breadcrumbs',
-      'plugin-browser-session'
+      'plugin-browser-session',
+      'plugin-http-errors'
     ], {
       testEnvironment: '<rootDir>/jest/FixJSDOMEnvironment.js'
     }),

packages/core/event.d.ts

@@ -1,4 +1,4 @@
-import { App, Device, Event, Request, Breadcrumb, User, Session, FeatureFlag } from './types'
+import { App, Device, Event, Request, Response, Breadcrumb, User, Session, FeatureFlag } from './types'
 import { Error } from './types/event'
 
 interface HandledState {
@@ -40,6 +40,7 @@ export default class EventWithInternals extends Event {
     app: App
     device: Device
     request: Request
+    response: Response
     breadcrumbs: Breadcrumb[]
     context: string | undefined
     correlation: { spanId: string, traceId: string } | undefined

packages/core/event.js

@@ -23,6 +23,7 @@ class Event {
     this.app = {}
     this.device = {}
     this.request = {}
+    this.response = {}
 
     this.breadcrumbs = []
     this.threads = []
@@ -120,6 +121,7 @@ class Event {
       app: this.app,
       device: this.device,
       request: this.request,
+      response: this.response,
       breadcrumbs: this.breadcrumbs,
       context: this.context,
       groupingHash: this.groupingHash,

packages/core/lib/json-payload.js

@@ -2,7 +2,8 @@ const jsonStringify = require('@bugsnag/safe-json-stringify')
 const EVENT_REDACTION_PATHS = [
   'events.[].metaData',
   'events.[].breadcrumbs.[].metaData',
-  'events.[].request'
+  'events.[].request',
+  'events.[].response'
 ]
 
 module.exports.event = (event, redactedKeys) => {

packages/core/types/common.d.ts

@@ -120,6 +120,13 @@ interface Request {
   [key: string]: any
 }
 
+interface Response {
+  statusCode: number
+  headers: { [key: string]: unknown }
+  body?: string
+  bodyLength?: number
+}
+
 export interface User {
   id?: string
   email?: string

packages/core/types/event.d.ts

@@ -3,6 +3,7 @@ import {
   App,
   Device,
   Request,
+  Response,
   Logger,
   User,
   Thread,
@@ -23,6 +24,7 @@ declare class Event {
   public app: App
   public device: Device
   public request: Request
+  public response: Response
 
   public errors: Error[];
   public breadcrumbs: Breadcrumb[]

packages/plugin-http-errors/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2025 Bugsnag
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the "Software"),
+to deal in the Software without restriction, including without limitation
+the rights to use, copy, modify, merge, publish, distribute, sublicense,
+and/or sell copies of the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
+OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

packages/plugin-http-errors/README.md

@@ -0,0 +1,45 @@
+# @bugsnag/plugin-http-errors
+
+A [@bugsnag/js](https://github.com/bugsnag/bugsnag-js) plugin for HTTP error handling.
+
+## Installation
+
+```sh
+npm install --save @bugsnag/plugin-http-errors
+# or
+yarn add @bugsnag/plugin-http-errors
+```
+
+## Usage
+
+```js
+import Bugsnag from '@bugsnag/js'
+import createHttpErrorPlugin from '@bugsnag/plugin-http-errors'
+
+const plugin = createHttpErrorPlugin({
+  httpErrorCodes: [401, { min: 404, max: 499 }], // handle individual error codes or ranges of error codes 
+  maxRequestSize: 5_000, // don't capture requests over 5kb
+  onHttpError: ({ request, response }) => {
+    // Only handle 5xx errors
+    if (response.statusCode < 500 || response.statusCode > 599) return false
+
+    // Exclude specific domains
+    if (request.url.indexOf('redacted.domain.com') === 0) return false
+
+    // Update properties on the reported request and response
+    request.url = '[REDACTED]'
+    response.statusCode = 418
+
+    return true // return value will determine whether the error is reported
+  }
+})
+
+Bugsnag.start({
+  apiKey: 'YOUR_API_KEY',
+  plugins: [plugin]
+})
+```
+
+## License
+
+This package is free software released under the MIT License. See [LICENSE.txt](./LICENSE.txt) for details.

packages/plugin-http-errors/http-errors.js

@@ -0,0 +1,169 @@
+/**
+ * @bugsnag/plugin-http-errors
+ * A plugin to automatically capture and report HTTP errors
+ */
+
+const extractDomain = require('./lib/extract-domain')
+const parseQueryParams = require('./lib/parse-query-params')
+const redactQueryParameters = require('./lib/redact-query-parameters')
+const shouldCaptureStatusCode = require('./lib/should-capture-status-code')
+const truncate = require('./lib/truncate')
+
+const DEFAULT_HTTP_ERROR_CODES = [{ min: 400, max: 599 }]
+const DEFAULT_MAX_REQUEST_SIZE = 5000
+
+/**
+ * Creates the HTTP errors plugin with configuration
+ * @param {Object} config - Plugin configuration
+ * @param {Array|Object|number} config.httpErrorCodes - Error codes to capture
+ * @param {number} config.maxResponseSize - Maximum response body size to capture
+ * @param {number} config.maxRequestSize - Maximum request body size to capture
+ * @param {Function} config.onHttpError - Callback for intercepting HTTP errors
+ * @returns {Object} Bugsnag plugin
+ */
+module.exports = (config = {}, global = window) => {
+  const {
+    httpErrorCodes = DEFAULT_HTTP_ERROR_CODES,
+    maxRequestSize = DEFAULT_MAX_REQUEST_SIZE,
+    onHttpError
+  } = config
+
+  // Normalize httpErrorCodes to an array
+  const normalizedStatusCodes = Array.isArray(httpErrorCodes) ? httpErrorCodes : [httpErrorCodes]
+
+  let restoreFunctions = []
+  const plugin = {
+    name: 'httpErrors',
+    load: (client) => {
+      // Try to get existing request tracker
+      let requestTrackerPlugin = client.getPlugin('requestTracker')
+
+      // Auto-load request tracker if not present
+      if (!requestTrackerPlugin) {
+        try {
+          const { createRequestTrackerPlugin } = require('@bugsnag/request-tracker')
+          const trackerPlugin = createRequestTrackerPlugin([], global)
+          client._loadPlugin(trackerPlugin)
+          requestTrackerPlugin = client.getPlugin('requestTracker')
+        } catch (error) {
+          client._logger.warn('Failed to auto-load request tracker, using direct fetch patching:', error.message)
+        }
+      }
+
+      // Use shared request tracker if available
+      if (requestTrackerPlugin) {
+        const { fetchTracker, xhrTracker } = requestTrackerPlugin
+
+        if (fetchTracker) {
+          restoreFunctions.push(fetchTracker._restore)
+          fetchTracker.onStart((startContext) => {
+            return {
+              onRequestEnd: (endContext) => {
+                handleHttpError(startContext, endContext)
+              }
+            }
+          })
+        }
+        if (xhrTracker) {
+          restoreFunctions.push(xhrTracker._restore)
+          xhrTracker.onStart((startContext) => {
+            return {
+              onRequestEnd: (endContext) => {
+                handleHttpError(startContext, endContext)
+              }
+            }
+          })
+        }
+      }
+
+      function handleHttpError (startContext, endContext) {
+        // Check if we should capture this status code
+        if (!shouldCaptureStatusCode(normalizedStatusCodes, endContext.status)) return
+
+        try {
+          // Extract request information
+          const url = startContext.url
+          const requestParams = parseQueryParams(url)
+          const method = startContext.method
+          const domain = extractDomain(url)
+
+          // Create request and response objects for callback
+          const requestObj = {
+            url: startContext.url,
+            httpMethod: startContext.method,
+            headers: startContext.headers,
+            params: requestParams,
+            body: startContext.body,
+            bodyLength: startContext.body ? startContext.body.length : undefined
+          }
+          const responseObj = {
+            statusCode: endContext.status,
+            headers: endContext.headers,
+            body: endContext.body,
+            bodyLength: endContext.body ? endContext.body.length : undefined
+          }
+
+          // Call onHttpError callback if provided
+          if (onHttpError) {
+            const result = onHttpError({ request: requestObj, response: responseObj })
+
+            // If onHttpError returns false, don't capture
+            if (result === false) {
+              return
+            }
+          }
+
+          // Truncate request body
+          if (requestObj.body) {
+            requestObj.body = truncate(requestObj.body, maxRequestSize)
+          }
+
+          // Truncate response body - XHR only
+          if (responseObj.body) {
+            responseObj.body = truncate(responseObj.body, maxRequestSize)
+          }
+
+          // Strip query parameters from URL
+          if (requestObj.url !== '[REDACTED]') {
+            requestObj.url = redactQueryParameters(requestObj.url, client._config.redactedKeys)
+          }
+
+          // Create error and notify
+          const error = new Error(`${responseObj.statusCode}: ${requestObj.url}`)
+          error.name = 'HTTPError'
+
+          const handledState = {
+            severity: 'error',
+            unhandled: true,
+            severityReason: { type: 'httpError' }
+          }
+
+          const event = client.Event.create(
+            error,
+            true,
+            handledState,
+            'http errors plugin',
+            0
+          )
+
+          event.request = requestObj
+          event.response = responseObj
+          event.context = `${method} ${domain}`
+
+          client._notify(event)
+        } catch (err) {
+          client._logger.error('Failed to process HTTP error:', err.message)
+        }
+      }
+    }
+  }
+
+  if (process.env.NODE_ENV !== 'production') {
+    plugin.destroy = () => {
+      restoreFunctions.forEach(fn => fn())
+      restoreFunctions = []
+    }
+  }
+
+  return plugin
+}

packages/plugin-http-errors/lib/extract-domain.js

@@ -0,0 +1,13 @@
+/**
+   * Extract domain from URL
+   * @param {string} url - URL string
+   * @returns {string} Domain
+   */
+module.exports = function (url) {
+  try {
+    const urlObj = new URL(url)
+    return urlObj.host
+  } catch (e) {
+    return 'unknown'
+  }
+}