rollbar 2.26.3 → 3.0.0-alpha.1

package/src/telemetry.js

@@ -1,15 +1,22 @@
 var _ = require('./utility');
 
-var MAX_EVENTS = 100;
+const MAX_EVENTS = 100;
 
-function Telemeter(options) {
+// Temporary workaround while solving commonjs -> esm issues in Node 18 - 20.
+function fromMillis(millis) {
+  return [Math.trunc(millis / 1000), Math.round((millis % 1000) * 1e6)];
+}
+
+function Telemeter(options, tracing) {
   this.queue = [];
   this.options = _.merge(options);
   var maxTelemetryEvents = this.options.maxTelemetryEvents || MAX_EVENTS;
   this.maxQueueSize = Math.max(0, Math.min(maxTelemetryEvents, MAX_EVENTS));
+  this.tracing = tracing;
+  this.telemetrySpan = this.tracing?.startSpan('rollbar-telemetry', {});
 }
 
-Telemeter.prototype.configure = function(options) {
+Telemeter.prototype.configure = function (options) {
   var oldOptions = this.options;
   this.options = _.merge(oldOptions, options);
   var maxTelemetryEvents = this.options.maxTelemetryEvents || MAX_EVENTS;
@@ -22,7 +29,7 @@ Telemeter.prototype.configure = function(options) {
   this.queue.splice(0, deleteCount);
 };
 
-Telemeter.prototype.copyEvents = function() {
+Telemeter.prototype.copyEvents = function () {
   var events = Array.prototype.slice.call(this.queue, 0);
   if (_.isFunction(this.options.filterTelemetry)) {
     try {
@@ -39,20 +46,29 @@ Telemeter.prototype.copyEvents = function() {
   return events;
 };
 
-Telemeter.prototype.capture = function(type, metadata, level, rollbarUUID, timestamp) {
+Telemeter.prototype.capture = function (
+  type,
+  metadata,
+  level,
+  rollbarUUID,
+  timestamp,
+) {
   var e = {
     level: getLevel(type, level),
     type: type,
     timestamp_ms: timestamp || _.now(),
     body: metadata,
-    source: 'client'
+    source: 'client',
   };
   if (rollbarUUID) {
     e.uuid = rollbarUUID;
   }
 
   try {
-    if (_.isFunction(this.options.filterTelemetry) && this.options.filterTelemetry(e)) {
+    if (
+      _.isFunction(this.options.filterTelemetry) &&
+      this.options.filterTelemetry(e)
+    ) {
       return false;
     }
   } catch (exc) {
@@ -63,37 +79,114 @@ Telemeter.prototype.capture = function(type, metadata, level, rollbarUUID, times
   return e;
 };
 
-Telemeter.prototype.captureEvent = function(type, metadata, level, rollbarUUID) {
+Telemeter.prototype.captureEvent = function (
+  type,
+  metadata,
+  level,
+  rollbarUUID,
+) {
   return this.capture(type, metadata, level, rollbarUUID);
 };
 
-Telemeter.prototype.captureError = function(err, level, rollbarUUID, timestamp) {
-  var metadata = {
-    message: err.message || String(err)
-  };
+Telemeter.prototype.captureError = function (
+  err,
+  level,
+  rollbarUUID,
+  timestamp,
+) {
+  const message = err.message || String(err);
+  var metadata = {message};
   if (err.stack) {
     metadata.stack = err.stack;
   }
+  this.telemetrySpan?.addEvent(
+    'rollbar-occurrence-event',
+    {
+      message,
+      level,
+      type: 'error',
+      uuid: rollbarUUID,
+      'occurrence.type': 'error', // deprecated
+      'occurrence.uuid': rollbarUUID, // deprecated
+    },
+
+    fromMillis(timestamp),
+  );
+
   return this.capture('error', metadata, level, rollbarUUID, timestamp);
 };
 
-Telemeter.prototype.captureLog = function(message, level, rollbarUUID, timestamp) {
-  return this.capture('log', {
-    message: message
-  }, level, rollbarUUID, timestamp);
+Telemeter.prototype.captureLog = function (
+  message,
+  level,
+  rollbarUUID,
+  timestamp,
+) {
+  // If the uuid is present, this is a message occurrence.
+  if (rollbarUUID) {
+    this.telemetrySpan?.addEvent(
+      'rollbar-occurrence-event',
+      {
+        message,
+        level,
+        type: 'message',
+        uuid: rollbarUUID,
+        'occurrence.type': 'message', // deprecated
+        'occurrence.uuid': rollbarUUID, // deprecated
+      },
+      fromMillis(timestamp),
+    );
+  } else {
+    this.telemetrySpan?.addEvent(
+      'rollbar-log-event',
+      {message, level},
+      fromMillis(timestamp),
+    );
+  }
+
+  return this.capture(
+    'log',
+    {message},
+    level,
+    rollbarUUID,
+    timestamp,
+  );
 };
 
-Telemeter.prototype.captureNetwork = function(metadata, subtype, rollbarUUID, requestData) {
+Telemeter.prototype.captureNetwork = function (
+  metadata,
+  subtype,
+  rollbarUUID,
+  requestData,
+) {
   subtype = subtype || 'xhr';
   metadata.subtype = metadata.subtype || subtype;
   if (requestData) {
     metadata.request = requestData;
   }
   var level = this.levelFromStatus(metadata.status_code);
-  return this.capture('network', metadata, level, rollbarUUID);
+
+  const endTimeNano = (metadata.end_time_ms || 0) * 1e6;
+
+  this.telemetrySpan?.addEvent(
+    'rollbar-network-event',
+    {
+      type: metadata.subtype,
+      method: metadata.method,
+      url : metadata.url,
+      statusCode : metadata.status_code,
+      'request.headers': JSON.stringify(metadata.request_headers || {}),
+      'response.headers': JSON.stringify(metadata.response?.headers || {}),
+      'response.timeUnixNano': endTimeNano.toString(),
+    },
+
+    fromMillis(metadata.start_time_ms)
+  );
+
+  return this.capture('network', metadata, level, rollbarUUID, metadata.start_time_ms);
 };
 
-Telemeter.prototype.levelFromStatus = function(statusCode) {
+Telemeter.prototype.levelFromStatus = function (statusCode) {
   if (statusCode >= 200 && statusCode < 400) {
     return 'info';
   }
@@ -103,10 +196,16 @@ Telemeter.prototype.levelFromStatus = function(statusCode) {
   return 'info';
 };
 
-Telemeter.prototype.captureDom = function(subtype, element, value, checked, rollbarUUID) {
+Telemeter.prototype.captureDom = function (
+  subtype,
+  element,
+  value,
+  checked,
+  rollbarUUID,
+) {
   var metadata = {
     subtype: subtype,
-    element: element
+    element: element,
   };
   if (value !== undefined) {
     metadata.value = value;
@@ -117,31 +216,55 @@ Telemeter.prototype.captureDom = function(subtype, element, value, checked, roll
   return this.capture('dom', metadata, 'info', rollbarUUID);
 };
 
-Telemeter.prototype.captureNavigation = function(from, to, rollbarUUID) {
-  return this.capture('navigation', {from: from, to: to}, 'info', rollbarUUID);
+Telemeter.prototype.captureNavigation = function (from, to, rollbarUUID, timestamp) {
+  this.telemetrySpan?.addEvent(
+    'rollbar-navigation-event',
+    {'previous.url.full': from, 'url.full': to},
+    fromMillis(timestamp),
+  );
+
+  return this.capture(
+    'navigation',
+    {from, to},
+    'info',
+    rollbarUUID,
+    timestamp,
+  );
 };
 
-Telemeter.prototype.captureDomContentLoaded = function(ts) {
-  return this.capture('navigation', {subtype: 'DOMContentLoaded'}, 'info', undefined, ts && ts.getTime());
+Telemeter.prototype.captureDomContentLoaded = function (ts) {
+  return this.capture(
+    'navigation',
+    { subtype: 'DOMContentLoaded' },
+    'info',
+    undefined,
+    ts && ts.getTime(),
+  );
   /**
    * If we decide to make this a dom event instead, then use the line below:
   return this.capture('dom', {subtype: 'DOMContentLoaded'}, 'info', undefined, ts && ts.getTime());
   */
 };
-Telemeter.prototype.captureLoad = function(ts) {
-  return this.capture('navigation', {subtype: 'load'}, 'info', undefined, ts && ts.getTime());
+Telemeter.prototype.captureLoad = function (ts) {
+  return this.capture(
+    'navigation',
+    { subtype: 'load' },
+    'info',
+    undefined,
+    ts && ts.getTime(),
+  );
   /**
    * If we decide to make this a dom event instead, then use the line below:
   return this.capture('dom', {subtype: 'load'}, 'info', undefined, ts && ts.getTime());
   */
 };
 
-Telemeter.prototype.captureConnectivityChange = function(type, rollbarUUID) {
-  return this.captureNetwork({change: type}, 'connectivity', rollbarUUID);
+Telemeter.prototype.captureConnectivityChange = function (type, rollbarUUID) {
+  return this.captureNetwork({ change: type }, 'connectivity', rollbarUUID);
 };
 
 // Only intended to be used internally by the notifier
-Telemeter.prototype._captureRollbarItem = function(item) {
+Telemeter.prototype._captureRollbarItem = function (item) {
   if (!this.options.includeItemsInTelemetry) {
     return;
   }
@@ -152,11 +275,17 @@ Telemeter.prototype._captureRollbarItem = function(item) {
     return this.captureLog(item.message, item.level, item.uuid, item.timestamp);
   }
   if (item.custom) {
-    return this.capture('log', item.custom, item.level, item.uuid, item.timestamp);
+    return this.capture(
+      'log',
+      item.custom,
+      item.level,
+      item.uuid,
+      item.timestamp,
+    );
   }
 };
 
-Telemeter.prototype.push = function(e) {
+Telemeter.prototype.push = function (e) {
   this.queue.push(e);
   if (this.queue.length > this.maxQueueSize) {
     this.queue.shift();
@@ -169,7 +298,7 @@ function getLevel(type, level) {
   }
   var defaultLevel = {
     error: 'error',
-    manual: 'info'
+    manual: 'info',
   };
   return defaultLevel[type] || 'info';
 }

package/src/tracing/context.js

@@ -0,0 +1,24 @@
+export class Context {
+  constructor(parentContext) {
+    this._currentContext = parentContext ? new Map(parentContext) : new Map();
+  }
+
+  getValue(key) {
+    return this._currentContext.get(key);
+  }
+
+  setValue (key, value) {
+    const context = new Context(this._currentContext);
+    context._currentContext.set(key, value);
+    return context;
+  }
+
+  deleteValue(key) {
+    const context = new Context(self._currentContext);
+    context._currentContext.delete(key);
+    return context;
+  }
+}
+
+export const ROOT_CONTEXT = new Context();
+

package/src/tracing/contextManager.js

@@ -0,0 +1,37 @@
+import { ROOT_CONTEXT } from './context.js';
+
+export class ContextManager {
+  constructor() {
+    this.currentContext = ROOT_CONTEXT;
+  }
+
+  active() {
+    return this.currentContext;
+  }
+
+  enterContext(context) {
+    const previousContext = this.currentContext;
+    this.currentContext = context || ROOT_CONTEXT;
+    return previousContext;
+  }
+
+  exitContext(context) {
+    this.currentContext = context;
+    return this.currentContext;
+  }
+
+  with(context, fn, thisArg, ...args) {
+    const previousContext = this.enterContext(context);
+    try {
+      return fn.call(thisArg, ...args);
+    } finally {
+      this.exitContext(previousContext);
+    }
+  }
+}
+
+export function createContextKey(key) {
+  // Use Symbol for OpenTelemetry compatibility.
+  return Symbol.for(key);
+}
+

package/src/tracing/defaults.js

@@ -0,0 +1,7 @@
+/**
+ * Default tracing options
+ */
+export default {
+  enabled: false,
+  endpoint: 'api.rollbar.com/api/1/session/',
+}

package/src/tracing/exporter.js

@@ -0,0 +1,188 @@
+import hrtime from './hrtime';
+
+/**
+ * SpanExporter is responsible for exporting ReadableSpan objects
+ * and transforming them into the OTLP-compatible format.
+ */
+export class SpanExporter {
+  /**
+   * Export spans to the span export queue
+   *
+   * @param {Array} spans - Array of ReadableSpan objects to export
+   * @param {Function} _resultCallback - Optional callback (not used)
+   */
+  export(spans, _resultCallback) {
+    console.log(spans); // console exporter, TODO: make optional
+    spanExportQueue.push(...spans);
+  }
+
+  /**
+   * Transforms an array of ReadableSpan objects into the OTLP format payload
+   * compatible with the Rollbar API. This follows the OpenTelemetry protocol
+   * specification for traces.
+   *
+   * @returns {Object} OTLP format payload for API transmission
+   */
+  toPayload() {
+    const spans = spanExportQueue.slice();
+    spanExportQueue.length = 0;
+
+    if (!spans || !spans.length) {
+      return { resourceSpans: [] };
+    }
+
+    const resource = (spans[0] && spans[0].resource) || {};
+
+    const scopeMap = new Map();
+
+    for (const span of spans) {
+      const scopeKey = span.instrumentationScope
+        ? `${span.instrumentationScope.name}:${span.instrumentationScope.version}`
+        : 'default:1.0.0';
+
+      if (!scopeMap.has(scopeKey)) {
+        scopeMap.set(scopeKey, {
+          scope: span.instrumentationScope || {
+            name: 'default',
+            version: '1.0.0',
+            attributes: [],
+          },
+          spans: [],
+        });
+      }
+
+      scopeMap.get(scopeKey).spans.push(this._transformSpan(span));
+    }
+
+    return {
+      resourceSpans: [
+        {
+          resource: this._transformResource(resource),
+          scopeSpans: Array.from(scopeMap.values()).map((scopeData) => ({
+            scope: this._transformInstrumentationScope(scopeData.scope),
+            spans: scopeData.spans,
+          })),
+        },
+      ],
+    };
+  }
+
+  /**
+   * Transforms a ReadableSpan into the OTLP Span format
+   *
+   * @private
+   * @param {Object} span - ReadableSpan object to transform
+   * @returns {Object} OTLP Span format
+   */
+  _transformSpan(span) {
+    const transformAttributes = (attributes) => {
+      return Object.entries(attributes || {}).map(([key, value]) => ({
+        key,
+        value: this._transformAnyValue(value),
+      }));
+    };
+
+    const transformEvents = (events) => {
+      return (events || []).map((event) => ({
+        timeUnixNano: hrtime.toNanos(event.time),
+        name: event.name,
+        attributes: transformAttributes(event.attributes),
+      }));
+    };
+
+    return {
+      traceId: span.spanContext.traceId,
+      spanId: span.spanContext.spanId,
+      parentSpanId: span.parentSpanId || '',
+      name: span.name,
+      kind: span.kind || 1, // INTERNAL by default
+      startTimeUnixNano: hrtime.toNanos(span.startTime),
+      endTimeUnixNano: hrtime.toNanos(span.endTime),
+      attributes: transformAttributes(span.attributes),
+      events: transformEvents(span.events),
+    };
+  }
+
+  /**
+   * Transforms a resource object into OTLP Resource format
+   *
+   * @private
+   * @param {Object} resource - Resource information
+   * @returns {Object} OTLP Resource format
+   */
+  _transformResource(resource) {
+    const attributes = resource.attributes || {};
+    const keyValues = Object.entries(attributes).map(([key, value]) => ({
+      key,
+      value: this._transformAnyValue(value),
+    }));
+
+    return {
+      attributes: keyValues,
+    };
+  }
+
+  /**
+   * Transforms an instrumentation scope into OTLP InstrumentationScope format
+   *
+   * @private
+   * @param {Object} scope - Instrumentation scope information
+   * @returns {Object} OTLP InstrumentationScope format
+   */
+  _transformInstrumentationScope(scope) {
+    return {
+      name: scope.name || '',
+      version: scope.version || '',
+      attributes: (scope.attributes || []).map((attr) => ({
+        key: attr.key,
+        value: this._transformAnyValue(attr.value),
+      })),
+    };
+  }
+
+  /**
+   * Transforms a JavaScript value into an OTLP AnyValue
+   *
+   * @private
+   * @param {any} value - Value to transform
+   * @returns {Object} OTLP AnyValue format
+   */
+  _transformAnyValue(value) {
+    if (value === null || value === undefined) {
+      return { stringValue: '' };
+    }
+
+    const type = typeof value;
+
+    if (type === 'string') {
+      return { stringValue: value };
+    } else if (type === 'number') {
+      if (Number.isInteger(value)) {
+        return { intValue: value.toString() };
+      } else {
+        return { doubleValue: value };
+      }
+    } else if (type === 'boolean') {
+      return { boolValue: value };
+    } else if (Array.isArray(value)) {
+      return {
+        arrayValue: {
+          values: value.map((v) => this._transformAnyValue(v)),
+        },
+      };
+    } else if (type === 'object') {
+      return {
+        kvlistValue: {
+          values: Object.entries(value).map(([k, v]) => ({
+            key: k,
+            value: this._transformAnyValue(v),
+          })),
+        },
+      };
+    }
+
+    return { stringValue: String(value) };
+  }
+}
+
+export const spanExportQueue = [];

package/src/tracing/hrtime.js

@@ -0,0 +1,98 @@
+/**
+ * @module hrtime
+ *
+ * @description Methods for handling OpenTelemetry hrtime.
+ */
+
+/**
+ * Convert a duration in milliseconds to an OpenTelemetry hrtime tuple.
+ *
+ * @param {number} millis - The duration in milliseconds.
+ * @returns {[number, number]} An array where the first element is seconds
+ *   and the second is nanoseconds.
+ */
+function fromMillis(millis) {
+  return [Math.trunc(millis / 1000), Math.round((millis % 1000) * 1e6)];
+}
+
+/**
+ * Convert an OpenTelemetry hrtime tuple back to a duration in milliseconds.
+ *
+ * @param {[number, number]} hrtime - The hrtime tuple [seconds, nanoseconds].
+ * @returns {number} The total duration in milliseconds.
+ */
+function toMillis(hrtime) {
+  return hrtime[0] * 1e3 + Math.round(hrtime[1] / 1e6);
+}
+
+/**
+ * Convert an OpenTelemetry hrtime tuple back to a duration in nanoseconds.
+ *
+ * @param {[number, number]} hrtime - The hrtime tuple [seconds, nanoseconds].
+ * @returns {number} The total duration in nanoseconds.
+ */
+function toNanos(hrtime) {
+  return hrtime[0] * 1e9 + hrtime[1];
+}
+
+/**
+ * Adds two OpenTelemetry hrtime tuples.
+ *
+ * @param {[number, number]} a - The first hrtime tuple [s, ns].
+ * @param {[number, number]} b - The second hrtime tuple [s, ns].
+ * @returns {[number, number]} Summed hrtime tuple, normalized.
+ *
+ */
+function add(a, b) {
+  return [a[0] + b[0] + Math.trunc((a[1] + b[1]) / 1e9), (a[1] + b[1]) % 1e9];
+}
+
+/**
+ * Get the current high-resolution time as an OpenTelemetry hrtime tuple.
+ *
+ * Uses the Performance API (timeOrigin + now()).
+ *
+ * @returns {[number, number]} The current hrtime tuple [s, ns].
+ */
+function now() {
+  return add(fromMillis(performance.timeOrigin), fromMillis(performance.now()));
+}
+
+/**
+ * Check if a value is a valid OpenTelemetry hrtime tuple.
+ *
+ * An hrtime tuple is an Array of exactly two numbers:
+ *   [seconds, nanoseconds]
+ *
+ * @param {*} value – anything to test
+ * @returns {boolean} true if `value` is a [number, number] array of length 2
+ *
+ * @example
+ * isHrTime([ 1, 500 ]);         // true
+ * isHrTime([ 0, 1e9 ]);         // true
+ * isHrTime([ '1', 500 ]);       // false
+ * isHrTime({ 0: 1, 1: 500 });   // false
+ */
+function isHrTime(value) {
+  return (
+    Array.isArray(value) &&
+    value.length === 2 &&
+    typeof value[0] === 'number' &&
+    typeof value[1] === 'number'
+  );
+}
+
+/**
+ * Methods for handling hrtime. OpenTelemetry uses the [seconds, nanoseconds]
+ * format for hrtime in the `ReadableSpan` interface.
+ *
+ * @example
+ * import hrtime from '@tracing/hrtime.js';
+ *
+ * hrtime.fromMillis(1000);
+ * hrtime.toMillis([0, 1000]);
+ * hrtime.add([0, 0], [0, 1000]);
+ * hrtime.now();
+ * hrtime.isHrTime([0, 1000]);
+ */
+export default { fromMillis, toMillis, toNanos, add, now, isHrTime };

package/src/tracing/id.js

@@ -0,0 +1,24 @@
+/**
+ * Generate a random hexadecimal ID of specified byte length
+ *
+ * @param {number} bytes - Number of bytes for the ID (default: 16)
+ * @returns {string} - Hexadecimal string representation
+ */
+function gen(bytes = 16) {
+  let randomBytes = new Uint8Array(bytes);
+  crypto.getRandomValues(randomBytes);
+  let randHex = Array.from(randomBytes, (byte) =>
+    byte.toString(16).padStart(2, '0'),
+  ).join('');
+  return randHex;
+}
+
+/**
+ * Tracing id generation utils
+ *
+ * @example
+ * import id from './id.js';
+ *
+ * const spanId = id.gen(8); // => "a1b2c3d4e5f6..."
+ */
+export default { gen };