Merge pull request #2640 from bugsnag/PLAT-15268/request-tracker-package

Create new request-tracker package

Author: gingerbenw

jest.config.js

@@ -29,7 +29,7 @@ module.exports = {
     project('web workers', ['web-worker'], {
       testEnvironment: '<rootDir>/jest/FixJSDOMEnvironment.js'
     }),
-    project('shared plugins', ['plugin-app-duration', 'plugin-stackframe-path-normaliser']),
+    project('shared plugins', ['plugin-app-duration', 'plugin-stackframe-path-normaliser', 'request-tracker']),
     project('browser', [
       'browser',
       'delivery-x-domain-request',

package-lock.json

@@ -0,0 +1,42 @@
+const RequestTracker = require('./lib/request-tracker')
+const createFetchTracker = require('./lib/fetch-tracker')
+const createXhrTracker = require('./lib/xhr-tracker')
+const { createUrlFilter, getDuration } = require('./lib/url-helpers')
+
+/**
+ * Create an auto-loading request tracker plugin
+ * @param {Array} ignoredUrls - Additional URLs to ignore
+ * @param {Object} global - Global object (window or global)
+ * @returns {Object} Bugsnag plugin
+ */
+function createRequestTrackerPlugin (ignoredUrls = [], global = window) {
+  return {
+    name: 'requestTracker',
+    load: (client) => {
+      try {
+        const fetchTracker = createFetchTracker(global)
+        const xhrTracker = createXhrTracker(global)
+        const urlFilter = createUrlFilter(client, ignoredUrls)
+
+        return {
+          fetchTracker,
+          xhrTracker,
+          urlFilter,
+          getDuration
+        }
+      } catch (error) {
+        client._logger.error('Failed to load request tracker:', error)
+        throw new Error('Request tracking is not available: ' + error.message)
+      }
+    }
+  }
+}
+
+module.exports = {
+  RequestTracker,
+  createFetchTracker,
+  createXhrTracker,
+  createUrlFilter,
+  getDuration,
+  createRequestTrackerPlugin
+}

packages/request-tracker/index.js

@@ -0,0 +1,91 @@
+const RequestTracker = require('./request-tracker')
+
+/**
+ * Create fetch request tracker with singleton pattern
+ * @param {Object} global - Global object (window or global)
+ * @param {Object} options - Configuration options
+ * @returns {Object} Tracker instance
+ */
+function createFetchTracker (global, options = {}) {
+  // only patch it if it exists and if it is not a polyfill (patching a polyfilled
+  // fetch() results in duplicate breadcrumbs for the same request because the
+  // implementation uses XMLHttpRequest which is also patched)
+  if (!('fetch' in global) || global.fetch.polyfill) return
+
+  // Use singleton pattern - one tracker per global context
+  if (!global.__bugsnag_fetch_tracker__) {
+    const tracker = new RequestTracker()
+    const originalFetch = global.fetch
+
+    global.fetch = function wrappedFetch (urlOrRequest, options = {}) {
+      let url = null
+      let method = 'GET'
+
+      if (urlOrRequest && typeof urlOrRequest === 'object') {
+        url = urlOrRequest.url
+        if (options && 'method' in options) {
+          method = options.method
+        } else if (urlOrRequest && 'method' in urlOrRequest) {
+          method = urlOrRequest.method
+        }
+      } else {
+        url = urlOrRequest
+        if (options && 'method' in options) {
+          method = options.method
+        }
+      }
+
+      if (method === undefined) {
+        method = 'GET'
+      }
+
+      const startTime = Date.now()
+      const context = {
+        url: String(url),
+        method: String(method),
+        startTime,
+        type: 'fetch',
+        input: urlOrRequest,
+        init: options
+      }
+
+      const { onRequestEnd } = tracker.start(context)
+
+      // Call original fetch
+      return originalFetch.call(this, ...arguments).then(
+        response => {
+          onRequestEnd({
+            endTime: Date.now(),
+            status: response.status,
+            state: 'success',
+            response
+          })
+          return response
+        },
+        error => {
+          onRequestEnd({
+            endTime: Date.now(),
+            state: 'error',
+            error
+          })
+          throw error
+        }
+      )
+    }
+
+    // Store tracker and mark as active
+    global.__bugsnag_fetch_tracker__ = tracker
+
+    // Restore function for development
+    if (process.env.NODE_ENV !== 'production') {
+      tracker._restore = () => {
+        global.fetch = originalFetch
+        delete global.__bugsnag_fetch_tracker__
+      }
+    }
+  }
+
+  return global.__bugsnag_fetch_tracker__
+}
+
+module.exports = createFetchTracker

packages/request-tracker/lib/fetch-tracker.js

@@ -0,0 +1,66 @@
+/**
+ * Singleton RequestTracker class for managing HTTP request instrumentation
+ * Allows multiple plugins to register callbacks for the same requests
+ */
+class RequestTracker {
+  constructor () {
+    this.callbacks = []
+  }
+
+  /**
+   * Register a callback to be called when a request starts
+   * @param {Function} callback - Function to call with request context
+   */
+  onStart (callback) {
+    if (typeof callback !== 'function') {
+      throw new Error('RequestTracker onStart callback must be a function')
+    }
+    this.callbacks.push(callback)
+  }
+
+  /**
+   * Notify all registered callbacks about a request start
+   * @param {Object} context - Request start context
+   * @returns {Object} Combined result with onRequestEnd callbacks
+   */
+  start (context) {
+    const results = this.callbacks
+      .map(callback => {
+        try {
+          return callback(context)
+        } catch (error) {
+          // Isolate plugin errors - don't let one plugin break others
+          console.error('RequestTracker callback error:', error)
+          return null
+        }
+      })
+      .filter(result => result && typeof result === 'object')
+
+    return {
+      onRequestEnd: (endContext) => {
+        results.forEach(result => {
+          if (typeof result.onRequestEnd === 'function') {
+            try {
+              result.onRequestEnd(endContext)
+            } catch (error) {
+              console.error('RequestTracker onRequestEnd callback error:', error)
+            }
+          }
+        })
+      },
+      extraRequestHeaders: results
+        .map(result => result.extraRequestHeaders)
+        .filter(headers => headers && typeof headers === 'object')
+        .reduce((combined, headers) => Object.assign(combined, headers), {})
+    }
+  }
+
+  /**
+   * Reset tracker (for testing)
+   */
+  _reset () {
+    this.callbacks = []
+  }
+}
+
+module.exports = RequestTracker

packages/request-tracker/lib/request-tracker.js

@@ -0,0 +1,46 @@
+const includes = require('@bugsnag/core/lib/es-utils/includes')
+
+/**
+ * Check if a URL should be ignored for tracking
+ * @param {string} url - URL to check
+ * @param {Array} ignoredUrls - Array of URLs to ignore
+ * @returns {boolean} True if URL should be ignored
+ */
+function shouldIgnoreUrl (url, ignoredUrls = []) {
+  if (!url || typeof url !== 'string') return true
+
+  // Remove query parameters for comparison
+  const urlWithoutQuery = url.replace(/\?.*$/, '')
+
+  return includes(ignoredUrls, urlWithoutQuery)
+}
+
+/**
+ * Create URL filtering function for Bugsnag endpoints and custom ignored URLs
+ * @param {Object} client - Bugsnag client instance
+ * @param {Array} additionalIgnoredUrls - Additional URLs to ignore
+ * @returns {Function} URL filtering function
+ */
+function createUrlFilter (client, additionalIgnoredUrls = []) {
+  const ignoredUrls = [
+    client._config.endpoints.notify,
+    client._config.endpoints.sessions
+  ].concat(additionalIgnoredUrls).filter(Boolean)
+
+  return (url) => shouldIgnoreUrl(url, ignoredUrls)
+}
+
+/**
+ * Calculate duration from start time
+ * @param {number} startTime - Start timestamp
+ * @returns {number} Duration in milliseconds
+ */
+function getDuration (startTime) {
+  return startTime && Date.now() - startTime
+}
+
+module.exports = {
+  shouldIgnoreUrl,
+  createUrlFilter,
+  getDuration
+}

packages/request-tracker/lib/url-helpers.js

@@ -0,0 +1,98 @@
+const RequestTracker = require('./request-tracker')
+
+/**
+ * Create XHR request tracker with singleton pattern
+ * @param {Object} global - Global object (window or global)
+ * @param {Object} options - Configuration options
+ * @returns {Object} Tracker instance
+ */
+function createXhrTracker (global, options = {}) {
+  if (!('addEventListener' in global.XMLHttpRequest.prototype) || !('WeakMap' in global)) return
+
+  // Use singleton pattern - one tracker per global context
+  if (!global.__bugsnag_xhr_tracker__) {
+    const tracker = new RequestTracker()
+
+    const trackedRequests = new WeakMap()
+    const requestHandlers = new WeakMap()
+
+    const originalOpen = global.XMLHttpRequest.prototype.open
+    const originalSend = global.XMLHttpRequest.prototype.send
+
+    global.XMLHttpRequest.prototype.open = function open (method, url) {
+      // it's possible for `this` to be `undefined`, which is not a valid key for a WeakMap
+      if (this) {
+        trackedRequests.set(this, { method: String(method), url: String(url) })
+      }
+      originalOpen.apply(this, arguments)
+    }
+
+    global.XMLHttpRequest.prototype.send = function send (body) {
+      const requestData = trackedRequests.get(this)
+      if (requestData) {
+        // if we have already setup listeners then this request instance is being reused,
+        // so we need to remove the listeners from the previous send
+        const listeners = requestHandlers.get(this)
+        if (listeners) {
+          this.removeEventListener('load', listeners.load)
+          this.removeEventListener('error', listeners.error)
+        }
+
+        const startTime = Date.now()
+        const context = {
+          url: requestData.url,
+          method: requestData.method,
+          startTime,
+          type: 'xmlhttprequest',
+          body,
+          xhr: this
+        }
+
+        const { onRequestEnd } = tracker.start(context)
+
+        const handleLoad = () => {
+          onRequestEnd({
+            endTime: Date.now(),
+            status: this.status,
+            state: 'success',
+            xhr: this
+          })
+        }
+
+        const handleError = () => {
+          onRequestEnd({
+            endTime: Date.now(),
+            state: 'error',
+            xhr: this
+          })
+        }
+
+        this.addEventListener('load', handleLoad)
+        this.addEventListener('error', handleError)
+
+        // it's possible for `this` to be `undefined`, which is not a valid key for a WeakMap
+        if (this) {
+          requestHandlers.set(this, { load: handleLoad, error: handleError })
+        }
+      }
+
+      originalSend.apply(this, arguments)
+    }
+
+    // Store tracker and mark as active
+    global.__bugsnag_xhr_tracker__ = tracker
+
+    // Restore function for development
+    if (process.env.NODE_ENV !== 'production') {
+      tracker._restore = () => {
+        global.XMLHttpRequest.prototype.open = originalOpen
+        global.XMLHttpRequest.prototype.send = originalSend
+        delete global.__bugsnag_xhr_tracker__
+      }
+    }
+  }
+
+  return global.__bugsnag_xhr_tracker__
+}
+
+module.exports = createXhrTracker