rollbar 2.26.3 → 3.0.0-alpha.1

package/src/tracing/session.js

@@ -0,0 +1,55 @@
+import id from './id.js';
+
+const SESSION_KEY = 'RollbarSession';
+
+export class Session {
+  constructor(tracing, options) {
+    this.options = options;
+    this.tracing = tracing;
+    this.window = tracing.window;
+    this.session = null;
+  }
+
+  init() {
+    if (this.session) {
+      return this;
+    }
+    return this.getSession() || this.createSession();
+  }
+
+  getSession() {
+    try {
+      const serializedSession = this.window.sessionStorage.getItem(SESSION_KEY);
+
+      if (!serializedSession) {
+        return null;
+      }
+
+      this.session = JSON.parse(serializedSession);
+    } catch {
+      return null;
+    }
+    return this;
+  }
+
+  createSession() {
+    this.session = {
+      id: id.gen(),
+      createdAt: Date.now(),
+    };
+
+    return this.setSession(this.session);
+  }
+
+  setSession(session) {
+    const sessionString = JSON.stringify(session);
+
+    try {
+      this.window.sessionStorage.setItem(SESSION_KEY, sessionString);
+    } catch {
+      return null;
+    }
+    return this;
+  }
+}
+

package/src/tracing/span.js

@@ -0,0 +1,92 @@
+import hrtime from './hrtime.js';
+
+export class Span {
+  constructor(options) {
+    this.initReadableSpan(options);
+
+    this.spanProcessor = options.spanProcessor;
+    this.spanProcessor.onStart(this, options.context);
+
+    if (options.attributes) {
+      this.setAttributes(options.attributes);
+    }
+    return this;
+  }
+
+  initReadableSpan(options) {
+    this.span = {
+      name: options.name,
+      kind: options.kind,
+      spanContext: options.spanContext,
+      parentSpanId: options.parentSpanId,
+      startTime: options.startTime || hrtime.now(),
+      endTime: [0, 0],
+      status: { code: 0, message: '' },
+      attributes: { 'session.id': options.session.id },
+      links: [],
+      events: [],
+      duration: 0,
+      ended: false,
+      resource: options.resource,
+      instrumentationScope: options.scope,
+      droppedAttributesCount: 0,
+      droppedEventsCount: 0,
+      droppedLinksCount: 0,
+    };
+  }
+
+  spanContext() {
+    return this.span.spanContext;
+  }
+
+  get spanId() {
+    return this.span.spanContext.spanId;
+  }
+
+  get traceId() {
+    return this.span.spanContext.traceId;
+  }
+
+  setAttribute(key, value) {
+    if (value == null || this.ended) return this;
+    if (key.length === 0) return this;
+
+    this.span.attributes[key] = value;
+    return this;
+  }
+
+  setAttributes(attributes) {
+    for (const [k, v] of Object.entries(attributes)) {
+      this.setAttribute(k, v);
+    }
+    return this;
+  }
+
+  addEvent(name, attributes = {}, time) {
+    if (this.span.ended) return this;
+
+    this.span.events.push({
+      name,
+      attributes,
+      time: time || hrtime.now(),
+      droppedAttributesCount: 0,
+    });
+
+    return this;
+  }
+
+  isRecording() {
+    return this.span.ended === false;
+  }
+
+  end(attributes, time) {
+    if (attributes) this.setAttributes(attributes);
+    this.span.endTime = time || hrtime.now();
+    this.span.ended = true;
+    this.spanProcessor.onEnd(this);
+  }
+
+  export() {
+    return this.span;
+  }
+}

package/src/tracing/spanProcessor.js

@@ -0,0 +1,15 @@
+export class SpanProcessor {
+  constructor(exporter) {
+    this.exporter = exporter;
+    this.pendingSpans = new Map()
+  }
+
+  onStart(span, _parentContext) {
+    this.pendingSpans.set(span.span.spanContext.spanId, span);
+  }
+
+  onEnd(span) {
+    this.exporter.export([span.export()])
+    this.pendingSpans.delete(span.span.spanContext.spanId);
+  }
+}

package/src/tracing/tracer.js

@@ -0,0 +1,46 @@
+import { Span } from './span.js';
+import id from './id.js';
+
+export class Tracer {
+  constructor(tracing, spanProcessor) {
+    this.spanProcessor = spanProcessor;
+    this.tracing = tracing;
+  }
+
+  startSpan(
+    name,
+    options = {},
+    context = this.tracing.contextManager.active()
+  ) {
+    const parentSpan = this.tracing.getSpan(context);
+    const parentSpanContext = parentSpan?.spanContext();
+    const spanId = id.gen(8);
+    let traceId;
+    let traceFlags = 0;
+    let traceState = null;
+    let parentSpanId;
+    if (parentSpanContext) {
+      traceId = parentSpanContext.traceId;
+      traceState = parentSpanContext.traceState;
+      parentSpanId = parentSpanContext.spanId;
+    } else {
+      traceId = id.gen(16);
+    }
+
+    const kind = 0;
+    const spanContext = { traceId, spanId, traceFlags, traceState };
+
+    const span = new Span({
+      resource: this.tracing.resource,
+      scope: this.tracing.scope,
+      session: this.tracing.session.session,
+      context,
+      spanContext,
+      name,
+      kind,
+      parentSpanId,
+      spanProcessor: this.spanProcessor,
+    });
+    return span;
+  }
+}

package/src/tracing/tracing.js

@@ -0,0 +1,89 @@
+import { ContextManager, createContextKey } from './contextManager.js';
+import { Session } from './session.js';
+import { SpanExporter } from './exporter.js';
+import { SpanProcessor } from './spanProcessor.js';
+import { Tracer } from './tracer.js';
+import id from './id.js';
+
+const SPAN_KEY = createContextKey('Rollbar Context Key SPAN');
+
+export default class Tracing {
+  constructor(gWindow, options) {
+    this.options = options;
+    this.window = gWindow;
+
+    this.session = new Session(this, options);
+    this.createTracer();
+  }
+
+  initSession() {
+    if (this.session) {
+      this.session.init();
+    }
+  }
+
+  get sessionId() {
+    if (this.session) {
+      return this.session.session.id;
+    }
+    return null;
+  }
+
+  get resource() {
+    return {
+      attributes: {
+        ...(this.options.resource || {}),
+        'rollbar.environment':
+          this.options.payload?.environment ?? this.options.environment,
+      },
+    };
+  }
+
+  get scope() {
+    return {
+      name: 'rollbar-browser-js',
+      version: this.options.version,
+    };
+  }
+
+  idGen(bytes = 16) {
+    return id.gen(bytes);
+  }
+
+  createTracer() {
+    this.contextManager = new ContextManager();
+    this.exporter = new SpanExporter();
+    this.spanProcessor = new SpanProcessor(this.exporter);
+    this.tracer = new Tracer(this, this.spanProcessor);
+  }
+
+  getTracer() {
+    return this.tracer;
+  }
+
+  getSpan(context = this.contextManager.active()) {
+    return context.getValue(SPAN_KEY);
+  }
+
+  setSpan(context = this.contextManager.active(), span) {
+    return context.setValue(SPAN_KEY, span);
+  }
+
+  startSpan(name, options = {}, context = this.contextManager.active()) {
+    return this.tracer.startSpan(name, options, context);
+  }
+
+  with(context, fn, thisArg, ...args) {
+    return this.contextManager.with(context, fn, thisArg, ...args);
+  }
+
+  withSpan(name, options, fn, thisArg) {
+    const span = this.startSpan(name, options);
+    return this.with(
+      this.setSpan(this.contextManager.active(), span),
+      fn,
+      thisArg,
+      span,
+    );
+  }
+}

package/src/transforms.js

@@ -42,19 +42,19 @@ function addMessageWithError(item, options, callback) {
   }
   if (trace) {
     if (!(trace.exception && trace.exception.description)) {
-      _.set(item, tracePath+'.exception.description', item.message);
+      _.set(item, tracePath + '.exception.description', item.message);
       callback(null, item);
       return;
     }
-    var extra = _.get(item, tracePath+'.extra') || {};
-    var newExtra =  _.merge(extra, {message: item.message});
-    _.set(item, tracePath+'.extra', newExtra);
+    var extra = _.get(item, tracePath + '.extra') || {};
+    var newExtra = _.merge(extra, { message: item.message });
+    _.set(item, tracePath + '.extra', newExtra);
   }
   callback(null, item);
 }
 
 function userTransform(logger) {
-  return function(item, options, callback) {
+  return function (item, options, callback) {
     var newItem = _.merge(item);
     var response = null;
     try {
@@ -63,23 +63,29 @@ function userTransform(logger) {
       }
     } catch (e) {
       options.transform = null;
-      logger.error('Error while calling custom transform() function. Removing custom transform().', e);
+      logger.error(
+        'Error while calling custom transform() function. Removing custom transform().',
+        e,
+      );
       callback(null, item);
       return;
     }
-    if(_.isPromise(response)) {
-      response.then(function (promisedItem) {
-        if(promisedItem) {
-          newItem.data = promisedItem;
-        }
-        callback(null, newItem);
-      }, function (error) {
-        callback(error, item);
-      });
+    if (_.isPromise(response)) {
+      response.then(
+        function (promisedItem) {
+          if (promisedItem) {
+            newItem.data = promisedItem;
+          }
+          callback(null, newItem);
+        },
+        function (error) {
+          callback(error, item);
+        },
+      );
     } else {
       callback(null, newItem);
     }
-  }
+  };
 }
 
 function addConfigToPayload(item, options, callback) {
@@ -94,7 +100,7 @@ function addConfigToPayload(item, options, callback) {
 }
 
 function addFunctionOption(options, name) {
-  if(_.isFunction(options[name])) {
+  if (_.isFunction(options[name])) {
     options[name] = options[name].toString();
   }
 }
@@ -113,7 +119,10 @@ function addConfiguredOptions(item, options, callback) {
 }
 
 function addDiagnosticKeys(item, options, callback) {
-  var diagnostic = _.merge(item.notifier.client.notifier.diagnostic, item.diagnostic);
+  var diagnostic = _.merge(
+    item.notifier.client.notifier.diagnostic,
+    item.diagnostic,
+  );
 
   if (_.get(item, 'err._isAnonymous')) {
     diagnostic.is_anonymous = true;
@@ -132,14 +141,17 @@ function addDiagnosticKeys(item, options, callback) {
         filename: item.err.fileName,
         line: item.err.lineNumber,
         column: item.err.columnNumber,
-        stack: item.err.stack
+        stack: item.err.stack,
       };
     } catch (e) {
       diagnostic.raw_error = { failed: String(e) };
     }
   }
 
-  item.data.notifier.diagnostic = _.merge(item.data.notifier.diagnostic, diagnostic);
+  item.data.notifier.diagnostic = _.merge(
+    item.data.notifier.diagnostic,
+    diagnostic,
+  );
   callback(null, item);
 }
 
@@ -151,5 +163,5 @@ module.exports = {
   userTransform: userTransform,
   addConfigToPayload: addConfigToPayload,
   addConfiguredOptions: addConfiguredOptions,
-  addDiagnosticKeys: addDiagnosticKeys
+  addDiagnosticKeys: addDiagnosticKeys,
 };

package/src/truncation.js

@@ -14,7 +14,7 @@ function selectFrames(frames, range) {
 }
 
 function truncateFrames(payload, jsonBackup, range) {
-  range = (typeof range === 'undefined') ? 30 : range;
+  range = typeof range === 'undefined' ? 30 : range;
   var body = payload.data.body;
   var frames;
   if (body.trace_chain) {
@@ -61,7 +61,10 @@ function truncateStrings(len, payload, jsonBackup) {
 function truncateTraceData(traceData) {
   if (traceData.exception) {
     delete traceData.exception.description;
-    traceData.exception.message = maybeTruncateValue(255, traceData.exception.message);
+    traceData.exception.message = maybeTruncateValue(
+      255,
+      traceData.exception.message,
+    );
   }
   traceData.frames = selectFrames(traceData.frames, 1);
   return traceData;
@@ -85,14 +88,14 @@ function needsTruncation(payload, maxSize) {
 }
 
 function truncate(payload, jsonBackup, maxSize) {
-  maxSize = (typeof maxSize === 'undefined') ? (512 * 1024) : maxSize;
+  maxSize = typeof maxSize === 'undefined' ? 512 * 1024 : maxSize;
   var strategies = [
     raw,
     truncateFrames,
     truncateStrings.bind(null, 1024),
     truncateStrings.bind(null, 512),
     truncateStrings.bind(null, 256),
-    minBody
+    minBody,
   ];
   var strategy, results, result;
 
@@ -114,5 +117,5 @@ module.exports = {
   raw: raw,
   truncateFrames: truncateFrames,
   truncateStrings: truncateStrings,
-  maybeTruncateValue: maybeTruncateValue
+  maybeTruncateValue: maybeTruncateValue,
 };

package/src/utility/headers.js

@@ -18,77 +18,77 @@ function headers(headers) {
 
 function normalizeName(name) {
   if (typeof name !== 'string') {
-    name = String(name)
+    name = String(name);
   }
-  return name.toLowerCase()
+  return name.toLowerCase();
 }
 
 function normalizeValue(value) {
   if (typeof value !== 'string') {
-    value = String(value)
+    value = String(value);
   }
-  return value
+  return value;
 }
 
 function iteratorFor(items) {
   var iterator = {
-    next: function() {
-      var value = items.shift()
-      return {done: value === undefined, value: value}
-    }
-  }
+    next: function () {
+      var value = items.shift();
+      return { done: value === undefined, value: value };
+    },
+  };
 
-  return iterator
+  return iterator;
 }
 
 function FetchHeaders(headers) {
-  this.map = {}
+  this.map = {};
 
   if (headers instanceof FetchHeaders) {
-    headers.forEach(function(value, name) {
-      this.append(name, value)
-    }, this)
+    headers.forEach(function (value, name) {
+      this.append(name, value);
+    }, this);
   } else if (Array.isArray(headers)) {
-    headers.forEach(function(header) {
-      this.append(header[0], header[1])
-    }, this)
+    headers.forEach(function (header) {
+      this.append(header[0], header[1]);
+    }, this);
   } else if (headers) {
-    Object.getOwnPropertyNames(headers).forEach(function(name) {
-      this.append(name, headers[name])
-    }, this)
+    Object.getOwnPropertyNames(headers).forEach(function (name) {
+      this.append(name, headers[name]);
+    }, this);
   }
 }
 
-FetchHeaders.prototype.append = function(name, value) {
-  name = normalizeName(name)
-  value = normalizeValue(value)
-  var oldValue = this.map[name]
-  this.map[name] = oldValue ? oldValue + ', ' + value : value
-}
+FetchHeaders.prototype.append = function (name, value) {
+  name = normalizeName(name);
+  value = normalizeValue(value);
+  var oldValue = this.map[name];
+  this.map[name] = oldValue ? oldValue + ', ' + value : value;
+};
 
-FetchHeaders.prototype.get = function(name) {
-  name = normalizeName(name)
-  return this.has(name) ? this.map[name] : null
-}
+FetchHeaders.prototype.get = function (name) {
+  name = normalizeName(name);
+  return this.has(name) ? this.map[name] : null;
+};
 
-FetchHeaders.prototype.has = function(name) {
-  return this.map.hasOwnProperty(normalizeName(name))
-}
+FetchHeaders.prototype.has = function (name) {
+  return this.map.hasOwnProperty(normalizeName(name));
+};
 
-FetchHeaders.prototype.forEach = function(callback, thisArg) {
+FetchHeaders.prototype.forEach = function (callback, thisArg) {
   for (var name in this.map) {
     if (this.map.hasOwnProperty(name)) {
-      callback.call(thisArg, this.map[name], name, this)
+      callback.call(thisArg, this.map[name], name, this);
     }
   }
-}
+};
 
-FetchHeaders.prototype.entries = function() {
-  var items = []
-  this.forEach(function(value, name) {
-    items.push([name, value])
-  })
-  return iteratorFor(items)
-}
+FetchHeaders.prototype.entries = function () {
+  var items = [];
+  this.forEach(function (value, name) {
+    items.push([name, value]);
+  });
+  return iteratorFor(items);
+};
 
 module.exports = headers;

package/src/utility/replace.js

@@ -0,0 +1,9 @@
+function replace(obj, name, replacement, replacements, type) {
+  var orig = obj[name];
+  obj[name] = replacement(orig);
+  if (replacements) {
+    replacements[type].push([obj, name, orig]);
+  }
+}
+
+module.exports = replace;

package/src/utility/traverse.js

@@ -8,7 +8,7 @@ function traverse(obj, func, seen) {
   var seenIndex;
 
   // Best might be to use Map here with `obj` as the keys, but we want to support IE < 11.
-  seen = seen || { obj: [], mapped: []};
+  seen = seen || { obj: [], mapped: [] };
 
   if (isObj) {
     seenIndex = seen.obj.indexOf(obj);