rollbar 2.26.4 → 3.0.0-alpha.2

package/src/telemetry.js

@@ -1,12 +1,19 @@
 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) {
@@ -87,12 +94,25 @@ Telemeter.prototype.captureError = function (
   rollbarUUID,
   timestamp,
 ) {
-  var metadata = {
-    message: err.message || String(err),
-  };
+  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);
 };
 
@@ -102,11 +122,31 @@ Telemeter.prototype.captureLog = function (
   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: message,
-    },
+    {message},
     level,
     rollbarUUID,
     timestamp,
@@ -125,7 +165,25 @@ Telemeter.prototype.captureNetwork = function (
     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) {
@@ -158,12 +216,19 @@ Telemeter.prototype.captureDom = function (
   return this.capture('dom', metadata, 'info', rollbarUUID);
 };
 
-Telemeter.prototype.captureNavigation = function (from, to, 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: from, to: to },
+    {from, to},
     'info',
     rollbarUUID,
+    timestamp,
   );
 };
 

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 };

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);
+  }
+}