rollbar 2.26.4 → 3.0.0-alpha.2

package/src/browser/replay/replayMap.js

@@ -0,0 +1,195 @@
+import id from '../../tracing/id.js';
+import logger from '../logger.js';
+
+/**
+ * ReplayMap - Manages the mapping between error occurrences and their associated
+ * session recordings. This class handles the coordination between when recordings
+ * are dumped and when they are eventually sent to the backend.
+ */
+export default class ReplayMap {
+  #map;
+  #recorder;
+  #api;
+  #tracing;
+
+  /**
+   * Creates a new ReplayMap instance
+   *
+   * @param {Object} props - Configuration props
+   * @param {Object} props.recorder - The recorder instance that dumps replay data into spans
+   * @param {Object} props.api - The API instance used to send replay payloads to the backend
+   * @param {Object} props.tracing - The tracing instance used to create spans and manage context
+   */
+  constructor({ recorder, api, tracing }) {
+    if (!recorder) {
+      throw new TypeError("Expected 'recorder' to be provided");
+    }
+
+    if (!api) {
+      throw new TypeError("Expected 'api' to be provided");
+    }
+
+    if (!tracing) {
+      throw new TypeError("Expected 'tracing' to be provided");
+    }
+
+    this.#map = new Map();
+    this.#recorder = recorder;
+    this.#api = api;
+    this.#tracing = tracing;
+  }
+
+  /**
+   * Processes a replay by converting recorder events into a transport-ready payload.
+   *
+   * Calls recorder.dump() to capture events as spans, formats them into a proper payload,
+   * and stores the result in the map using replayId as the key.
+   *
+   * @param {string} replayId - The unique ID for this replay
+   * @returns {Promise<string>} A promise resolving to the processed replayId
+   * @private
+   */
+  async _processReplay(replayId, occurrenceUuid) {
+    try {
+      const payload = this.#recorder.dump(
+        this.#tracing,
+        replayId,
+        occurrenceUuid,
+      );
+
+      this.#map.set(replayId, payload);
+    } catch (transformError) {
+      logger.error('Error transforming spans:', transformError);
+
+      this.#map.set(replayId, null); // TODO(matux): Error span?
+    }
+
+    return replayId;
+  }
+
+  /**
+   * Adds a replay to the map and returns a uniquely generated replay ID.
+   *
+   * This method immediately returns the replayId and asynchronously processes
+   * the replay data in the background. The processing involves converting
+   * recorder events into a payload format and storing it in the map.
+   *
+   * @returns {string} A unique identifier for this replay
+   */
+  add(replayId, occurrenceUuid) {
+    replayId = replayId || id.gen(8);
+
+    this._processReplay(replayId, occurrenceUuid).catch((error) => {
+      logger.error('Failed to process replay:', error);
+    });
+
+    return replayId;
+  }
+
+  /**
+   * Sends the replay payload associated with the given replayId to the backend
+   * and removes it from the map.
+   *
+   * Retrieves the payload from the map, checks if it's valid, then sends it
+   * to the API endpoint for processing. The payload can be either a spans array
+   * or a formatted OTLP payload object.
+   *
+   * @param {string} replayId - The ID of the replay to send
+   * @returns {Promise<boolean>} A promise that resolves to true if the payload was found and sent, false otherwise
+   */
+  async send(replayId) {
+    if (!replayId) {
+      logger.error('ReplayMap.send: No replayId provided');
+      return false;
+    }
+
+    if (!this.#map.has(replayId)) {
+      logger.error(`ReplayMap.send: No replay found for replayId: ${replayId}`);
+      return false;
+    }
+
+    const payload = this.#map.get(replayId);
+    this.#map.delete(replayId);
+
+    // Check if payload is empty (could be raw spans array or OTLP payload)
+    const isEmpty =
+      !payload ||
+      (Array.isArray(payload) && payload.length === 0) ||
+      (payload.resourceSpans && payload.resourceSpans.length === 0);
+
+    if (isEmpty) {
+      logger.error(
+        `ReplayMap.send: No payload found for replayId: ${replayId}`,
+      );
+      return false;
+    }
+
+    try {
+      await this.#api.postSpans(payload);
+      return true;
+    } catch (error) {
+      logger.error('Error sending replay:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Discards the replay associated with the given replay ID by removing
+   * it from the map without sending it.
+   *
+   * @param {string} replayId - The ID of the replay to discard
+   * @returns {boolean} True if a replay was found and discarded, false otherwise
+   */
+  discard(replayId) {
+    if (!replayId) {
+      logger.error('ReplayMap.discard: No replayId provided');
+      return false;
+    }
+
+    if (!this.#map.has(replayId)) {
+      logger.error(
+        `ReplayMap.discard: No replay found for replayId: ${replayId}`,
+      );
+      return false;
+    }
+
+    this.#map.delete(replayId);
+    return true;
+  }
+
+  /**
+   * Gets spans for the given replay ID
+   *
+   * @param {string} replayId - The ID to retrieve spans for
+   * @returns {Array|null} The spans array or null if not found
+   */
+  getSpans(replayId) {
+    return this.#map.get(replayId) ?? null;
+  }
+
+  /**
+   * Sets spans for a given replay ID
+   *
+   * @param {string} replayId - The ID to set spans for
+   * @param {Array} spans - The spans to set
+   */
+  setSpans(replayId, spans) {
+    this.#map.set(replayId, spans);
+  }
+
+  /**
+   * Returns the size of the map (number of stored replays)
+   *
+   * @returns {number} The number of replays currently stored
+   */
+  get size() {
+    return this.#map.size;
+  }
+
+  /**
+   * Clears all stored replays without sending them
+   */
+  clear() {
+    this.#map.clear();
+  }
+}

package/src/browser/rollbar.js

@@ -1,10 +1,12 @@
-var Rollbar = require('./core');
-var telemeter = require('../telemetry');
-var instrumenter = require('./telemetry');
-var polyfillJSON = require('../utility/polyfillJSON');
-var wrapGlobals = require('./wrapGlobals');
-var scrub = require('../scrub');
-var truncation = require('../truncation');
+const Rollbar = require('./core');
+const telemeter = require('../telemetry');
+const instrumenter = require('./telemetry');
+const polyfillJSON = require('../utility/polyfillJSON');
+const wrapGlobals = require('./wrapGlobals');
+const scrub = require('../scrub');
+const truncation = require('../truncation');
+const Tracing = require('../tracing/tracing');
+const Recorder = require('./replay/recorder');
 
 Rollbar.setComponents({
   telemeter: telemeter,
@@ -13,6 +15,8 @@ Rollbar.setComponents({
   wrapGlobals: wrapGlobals,
   scrub: scrub,
   truncation: truncation,
+  tracing: Tracing.default,
+  recorder: Recorder.default,
 });
 
 module.exports = Rollbar;

package/src/browser/telemetry.js

@@ -613,7 +613,7 @@ Instrumenter.prototype.instrumentConsole = function () {
     c[method] = function () {
       var args = Array.prototype.slice.call(arguments);
       var message = _.formatArgsAsString(args);
-      self.telemeter.captureLog(message, level);
+      self.telemeter.captureLog(message, level, null, _.now());
       if (orig) {
         Function.prototype.apply.call(orig, origConsole, args);
       }
@@ -822,7 +822,7 @@ Instrumenter.prototype.handleUrlChange = function (from, to) {
   ) {
     from = parsedFrom.path + (parsedFrom.hash || '');
   }
-  this.telemeter.captureNavigation(from, to);
+  this.telemeter.captureNavigation(from, to, null, _.now());
 };
 
 Instrumenter.prototype.deinstrumentConnectivity = function () {
@@ -922,7 +922,7 @@ Instrumenter.prototype.handleCspEvent = function (cspEvent) {
 
   message += 'originalPolicy: ' + cspEvent.originalPolicy;
 
-  this.telemeter.captureLog(message, 'error');
+  this.telemeter.captureLog(message, 'error', null, _.now());
   this.handleCspError(message);
 };
 

package/src/browser/transport/fetch.js

@@ -23,10 +23,23 @@ function makeFetchRequest(accessToken, url, method, data, callback, timeout) {
   })
     .then(function (response) {
       if (timeoutId) clearTimeout(timeoutId);
-      return response.json();
-    })
-    .then(function (data) {
-      callback(null, data);
+      const respHeaders = response.headers;
+
+      const isItemRoute = url.endsWith('/api/1/item/');
+      const headers = isItemRoute
+        ? {
+            'Rollbar-Replay-Enabled': respHeaders.get('Rollbar-Replay-Enabled'),
+            'Rollbar-Replay-RateLimit-Remaining': respHeaders.get(
+              'Rollbar-Replay-RateLimit-Remaining',
+            ),
+            'Rollbar-Replay-RateLimit-Reset': respHeaders.get(
+              'Rollbar-Replay-RateLimit-Reset',
+            ),
+          }
+        : {};
+
+      const json = response.json();
+      callback(null, json, headers);
     })
     .catch(function (error) {
       logger.error(error.message);

package/src/browser/transport/xhr.js

@@ -31,7 +31,23 @@ function makeXhrRequest(
 
             var parseResponse = _.jsonParse(request.responseText);
             if (_isSuccess(request)) {
-              callback(parseResponse.error, parseResponse.value);
+              const isItemRoute = url.endsWith('/api/1/item/');
+
+              const headers = isItemRoute
+                ? {
+                    'Rollbar-Replay-Enabled': request.getResponseHeader(
+                      'Rollbar-Replay-Enabled',
+                    ),
+                    'Rollbar-Replay-RateLimit-Remaining':
+                      request.getResponseHeader(
+                        'Rollbar-Replay-RateLimit-Remaining',
+                      ),
+                    'Rollbar-Replay-RateLimit-Reset': request.getResponseHeader(
+                      'Rollbar-Replay-RateLimit-Reset',
+                    ),
+                  }
+                : {};
+              callback(parseResponse.error, parseResponse.value, headers);
               return;
             } else if (_isNormalFailure(request)) {
               if (request.status === 403) {

package/src/browser/transport.js

@@ -66,7 +66,8 @@ Transport.prototype.post = function (
   }
 
   var stringifyResult;
-  if (this.truncation) {
+  // Check payload.body to ensure only items are truncated.
+  if (this.truncation && payload.body) {
     stringifyResult = this.truncation.truncate(payload);
   } else {
     stringifyResult = _.stringify(payload);
@@ -115,19 +116,21 @@ Transport.prototype.postJsonPayload = function (
   );
 };
 
-// Wraps _makeRequest and if Angular 2+ Zone.js is detected, changes scope
-// so Angular change detection isn't triggered on each API call.
-// This is the equivalent of runOutsideAngular().
-//
+// Wraps `_makeRequest` if zone.js is being used, ensuring that Rollbar
+// API calls are not intercepted by any child forked zones.
+// This is equivalent to `NgZone.runOutsideAngular` in Angular.
 Transport.prototype._makeZoneRequest = function () {
   var gWindow =
     (typeof window != 'undefined' && window) ||
     (typeof self != 'undefined' && self);
-  var currentZone = gWindow && gWindow.Zone && gWindow.Zone.current;
+  // Whenever zone.js is loaded and `Zone` is exposed globally, access
+  // the root zone to ensure that requests are always made within it.
+  // This approach is framework-agnostic, regardless of which
+  // framework zone.js is used with.
+  var rootZone = gWindow && gWindow.Zone && gWindow.Zone.root;
   var args = Array.prototype.slice.call(arguments);
 
-  if (currentZone && currentZone._name === 'angular') {
-    var rootZone = currentZone._parent;
+  if (rootZone) {
     var self = this;
     rootZone.run(function () {
       self._makeRequest.apply(undefined, args);

package/src/defaults.js

@@ -1,5 +1,5 @@
 module.exports = {
-  version: '2.26.4',
+  version: '3.0.0-alpha.2',
   endpoint: 'api.rollbar.com/api/1/item/',
   logLevel: 'debug',
   reportLevel: 'debug',

package/src/queue.js

@@ -12,12 +12,14 @@ var _ = require('./utility');
  *    api.postItem(payload, function(err, response))
  * @param logger - An object used to log verbose messages if desired
  * @param options - see Queue.prototype.configure
+ * @param replayMap - Optional ReplayMap for coordinating session replay with error occurrences
  */
-function Queue(rateLimiter, api, logger, options) {
+function Queue(rateLimiter, api, logger, options, replayMap) {
   this.rateLimiter = rateLimiter;
   this.api = api;
   this.logger = logger;
   this.options = options;
+  this.replayMap = replayMap;
   this.predicates = [];
   this.pendingItems = [];
   this.pendingRequests = [];
@@ -99,12 +101,25 @@ Queue.prototype.addItem = function (
     callback(new Error('Transmit disabled'));
     return;
   }
+
+  if (this.replayMap && item.body) {
+    const replayId = _.getItemAttribute(item, 'replay_id');
+    if (replayId) {
+      item.replayId = this.replayMap.add(replayId, item.uuid);
+    }
+  }
+
   this.pendingRequests.push(item);
   try {
     this._makeApiRequest(
       item,
-      function (err, resp) {
+      function (err, resp, headers) {
         this._dequeuePendingRequest(item);
+
+        if (!err && resp && item.replayId) {
+          this._handleReplayResponse(item.replayId, resp, headers);
+        }
+
         callback(err, resp);
       }.bind(this),
     );
@@ -169,11 +184,11 @@ Queue.prototype._makeApiRequest = function (item, callback) {
   if (rateLimitResponse.shouldSend) {
     this.api.postItem(
       item,
-      function (err, resp) {
+      function (err, resp, headers) {
         if (err) {
           this._maybeRetry(err, item, callback);
         } else {
-          callback(err, resp);
+          callback(err, resp, headers);
         }
       }.bind(this),
     );
@@ -297,4 +312,50 @@ Queue.prototype._maybeCallWait = function () {
   return false;
 };
 
+/**
+ * Handles the API response for an item with a replay ID.
+ * Based on the success or failure status of the response,
+ * it either sends or discards the associated session replay.
+ *
+ * @param {string} replayId - The ID of the replay to handle
+ * @param {Object} response - The API response
+ * @returns {Promise<boolean>} A promise that resolves to true if replay was sent successfully,
+ *                             false if replay was discarded or an error occurred
+ * @private
+ */
+Queue.prototype._handleReplayResponse = async function (replayId, response, headers) {
+  if (!this.replayMap) {
+    console.warn('Queue._handleReplayResponse: ReplayMap not available');
+    return false;
+  }
+
+  if (!replayId) {
+    console.warn('Queue._handleReplayResponse: No replayId provided');
+    return false;
+  }
+
+  try {
+    if (this._shouldSendReplay(response, headers)) {
+      return await this.replayMap.send(replayId);
+    } else {
+      this.replayMap.discard(replayId);
+      return false;
+    }
+  } catch (error) {
+    console.error('Error handling replay response:', error);
+    return false;
+  }
+};
+
+Queue.prototype._shouldSendReplay = function (response, headers) {
+  if (response?.err !== 0 ||
+      !headers ||
+      headers['Rollbar-Replay-Enabled'] !== 'true' ||
+      headers['Rollbar-Replay-RateLimit-Remaining'] === '0') {
+    return false;
+  }
+
+  return true;
+};
+
 module.exports = Queue;

package/src/react-native/rollbar.js

@@ -30,7 +30,7 @@ function Rollbar(options, client) {
   var api = new API(this.options, transport, urllib, truncation);
   var telemeter = new Telemeter(this.options);
   this.client =
-    client || new Client(this.options, api, logger, telemeter, 'react-native');
+    client || new Client(this.options, api, logger, telemeter, null, null, 'react-native');
   addTransformsToNotifier(this.client.notifier);
   addPredicatesToQueue(this.client.queue);
   _.setupJSON(polyfillJSON);

package/src/rollbar.js

@@ -1,7 +1,7 @@
-var RateLimiter = require('./rateLimiter');
-var Queue = require('./queue');
-var Notifier = require('./notifier');
-var _ = require('./utility');
+const RateLimiter = require('./rateLimiter');
+const Queue = require('./queue');
+const Notifier = require('./notifier');
+const _ = require('./utility');
 
 /*
  * Rollbar - the interface to Rollbar
@@ -10,14 +10,17 @@ var _ = require('./utility');
  * @param api
  * @param logger
  */
-function Rollbar(options, api, logger, telemeter, platform) {
+function Rollbar(options, api, logger, telemeter, tracing, replayMap, platform) {
   this.options = _.merge(options);
   this.logger = logger;
   Rollbar.rateLimiter.configureGlobal(this.options);
   Rollbar.rateLimiter.setPlatformOptions(platform, this.options);
   this.api = api;
-  this.queue = new Queue(Rollbar.rateLimiter, api, logger, this.options);
+  this.queue = new Queue(Rollbar.rateLimiter, api, logger, this.options, replayMap);
 
+  this.tracing = tracing;
+
+  // Legacy OpenTracing support
   // This must happen before the Notifier is created
   var tracer = this.options.tracer || null;
   if (validateTracer(tracer)) {
@@ -57,6 +60,7 @@ Rollbar.prototype.configure = function (options, payloadData) {
 
   this.options = _.merge(oldOptions, options, payload);
 
+  // Legacy OpenTracing support
   // This must happen before the Notifier is configured
   var tracer = this.options.tracer || null;
   if (validateTracer(tracer)) {
@@ -150,11 +154,25 @@ Rollbar.prototype._log = function (defaultLevel, item) {
     return;
   }
   try {
-    this._addTracingInfo(item);
     item.level = item.level || defaultLevel;
-    this.telemeter && this.telemeter._captureRollbarItem(item);
-    item.telemetryEvents =
-      (this.telemeter && this.telemeter.copyEvents()) || [];
+
+    const replayId = this._replayIdIfTriggered(item);
+    this._addTracingAttributes(item, replayId);
+
+    // Legacy OpenTracing support
+    this._addTracingInfo(item);
+
+    const telemeter = this.telemeter;
+    if (telemeter) {
+      telemeter._captureRollbarItem(item);
+      item.telemetryEvents = telemeter.copyEvents() || [];
+
+      if (telemeter.telemetrySpan) {
+        telemeter.telemetrySpan.end({'rollbar.replay.id': replayId});
+        telemeter.telemetrySpan = telemeter.tracing.startSpan('rollbar-telemetry', {});
+      }
+    }
+
     this.notifier.log(item, callback);
   } catch (e) {
     if (callback) {
@@ -164,6 +182,30 @@ Rollbar.prototype._log = function (defaultLevel, item) {
   }
 };
 
+Rollbar.prototype._addTracingAttributes = function (item, replayId) {
+  const span = this.tracing?.getSpan();
+
+  const attributes = [
+    {key: 'replay_id', value: replayId},
+    {key: 'session_id', value: this.tracing?.sessionId},
+    {key: 'span_id', value: span?.spanId},
+    {key: 'trace_id', value: span?.traceId},
+  ];
+  _.addItemAttributes(item.data, attributes);
+
+  span?.addEvent(
+    'rollbar.occurrence',
+    [{key: 'rollbar.occurrence.uuid', value: item.uuid}],
+  );
+};
+
+Rollbar.prototype._replayIdIfTriggered = function (item) {
+  const levels = this.options.recorder?.triggerOptions?.item?.levels || [];
+  if (levels.includes(item.level)) {
+    return this.tracing?.idGen(8);
+  }
+}
+
 Rollbar.prototype._defaultLogLevel = function () {
   return this.options.logLevel || 'debug';
 };

package/src/server/rollbar.js

@@ -41,7 +41,7 @@ function Rollbar(options, client) {
   var api = new API(this.options, transport, urllib, truncation, jsonBackup);
   var telemeter = new Telemeter(this.options);
   this.client =
-    client || new Client(this.options, api, logger, telemeter, 'server');
+    client || new Client(this.options, api, logger, telemeter, null, null, 'server');
   this.instrumenter = new Instrumenter(
     this.options,
     this.client.telemeter,
@@ -250,8 +250,9 @@ Rollbar.error = function () {
 Rollbar.prototype._uncaughtError = function () {
   var item = this._createItem(arguments);
   item._isUncaught = true;
+  item.level = this.options.uncaughtErrorLevel;
   var uuid = item.uuid;
-  this.client.error(item);
+  this.client.log(item);
   return { uuid: uuid };
 };