rollbar 3.0.0 → 3.1.0

package/index.d.ts

@@ -33,6 +33,7 @@ declare class Rollbar implements Rollbar.Components {
   ): Rollbar.LambdaHandler<T>;
 
   public errorHandler(): Rollbar.ExpressErrorHandler;
+  public expressMiddleware(): Rollbar.ExpressMiddleware | undefined;
 
   // Components
 
@@ -219,6 +220,11 @@ declare namespace Rollbar {
     response: any,
     next: ExpressNextFunction,
   ) => any;
+  export type ExpressMiddleware = (
+    request: any,
+    response: any,
+    next: ExpressNextFunction,
+  ) => any;
   export type ExpressNextFunction = (err?: any) => void;
   class Locals {}
   export type LocalsType = typeof Locals;
@@ -333,9 +339,18 @@ declare namespace Rollbar {
   export interface TransformSpanParams {
     span: any;
   }
+  export type TracingPropagationHeader =
+    | 'baggage'
+    | 'traceparent'
+    | 'tracestate';
+  export interface TracingPropagationOptions {
+    enabledHeaders?: TracingPropagationHeader[];
+    enabledCorsUrls?: (string | RegExp)[];
+  }
   export interface TracingOptions {
     enabled?: boolean;
     endpoint?: string;
+    propagation?: TracingPropagationOptions;
     transformSpan?: (params: TransformSpanParams) => void;
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollbar",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -125,6 +125,7 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.46.4",
+    "undici": "^6.23.0",
     "webpack": "^5.98.0",
     "webpack-cli": "^6.0.1",
     "webpack-node-externals": "^3.0.0"

package/src/browser/telemetry.js

@@ -284,6 +284,23 @@ class Instrumenter {
         function (orig) {
           return function (data) {
             const xhr = this;
+            const tracing = self.rollbar?.tracing;
+            if (
+              _.shouldAddBaggageHeader(
+                self.options,
+                tracing,
+                xhr.__rollbar_xhr?.url,
+              )
+            ) {
+              try {
+                xhr.setRequestHeader(
+                  'baggage',
+                  `rollbar.session.id=${tracing.sessionId}`,
+                );
+              } catch (_e) {
+                /* ignore errors from adding baggage header */
+              }
+            }
 
             function onreadystatechangeHandler() {
               if (xhr.__rollbar_xhr) {
@@ -435,6 +452,14 @@ class Instrumenter {
             if (args[1] && args[1].method) {
               method = args[1].method;
             }
+            const tracing = self.rollbar?.tracing;
+            if (_.shouldAddBaggageHeader(self.options, tracing, url)) {
+              const headers = {
+                baggage: `rollbar.session.id=${tracing.sessionId}`,
+              };
+
+              _.addHeadersToFetch(args, headers);
+            }
             const metadata = {
               method: method,
               url: url,

package/src/defaults.js

@@ -1,7 +1,7 @@
 /**
  * Default options shared across platforms
  */
-export const version = '3.0.0';
+export const version = '3.1.0';
 export const endpoint = 'api.rollbar.com/api/1/item/';
 export const logLevel = 'debug';
 export const reportLevel = 'debug';

package/src/rollbar.js

@@ -184,9 +184,11 @@ Rollbar.prototype._log = function (defaultLevel, item) {
 
 Rollbar.prototype._addItemAttributes = function (item) {
   const span = this.tracing?.getSpan();
+  const asyncLocalSessionId = _.getSessionIdFromAsyncLocalStorage(this);
+  const sessionId = asyncLocalSessionId || this.tracing?.sessionId;
 
   const attributes = [
-    { key: 'session_id', value: this.tracing?.sessionId },
+    { key: 'session_id', value: sessionId },
     { key: 'span_id', value: span?.spanId },
     { key: 'trace_id', value: span?.traceId },
   ];

package/src/server/middleware/rollbarExpressMiddleware.js

@@ -0,0 +1,63 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+export function extractSessionId(headerValue) {
+  if (!headerValue) {
+    return null;
+  }
+  const rawValue = Array.isArray(headerValue)
+    ? headerValue.join(',')
+    : headerValue;
+  if (typeof rawValue !== 'string') {
+    return null;
+  }
+  const entries = rawValue.split(',');
+  for (const entry of entries) {
+    const trimmed = entry.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const equalsIndex = trimmed.indexOf('=');
+    if (equalsIndex === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, equalsIndex).trim();
+    if (key !== 'rollbar.session.id') {
+      continue;
+    }
+    const value = trimmed.slice(equalsIndex + 1).trim();
+    if (!value) {
+      return null;
+    }
+    try {
+      return decodeURIComponent(value);
+    } catch (_e) {
+      return value;
+    }
+  }
+  return null;
+}
+
+function getBaggageHeader(req) {
+  if (!req) {
+    return null;
+  }
+  if (typeof req.get === 'function') {
+    return req.get('baggage');
+  }
+  return req.headers?.baggage || null;
+}
+
+export default function rollbarExpressMiddleware(rollbar) {
+  const storage = rollbar?.client.asyncLocalStorage || new AsyncLocalStorage();
+  if (rollbar) {
+    rollbar.client.asyncLocalStorage = storage;
+  }
+
+  return function rollbarExpressMiddlewareHandler(req, _res, next) {
+    const sessionId = extractSessionId(getBaggageHeader(req));
+    if (!sessionId) {
+      return next();
+    }
+    return storage.run({ sessionId }, () => next());
+  };
+}

package/src/server/rollbar.js

@@ -15,6 +15,7 @@ import truncation from '../truncation.js';
 import * as _ from '../utility.js';
 
 import * as serverDefaults from './defaults.js';
+import rollbarExpressMiddleware from './middleware/rollbarExpressMiddleware.js';
 import Instrumenter from './telemetry.js';
 import * as transforms from './transforms.js';
 import Transport from './transport.js';
@@ -460,6 +461,18 @@ Rollbar.wrapCallback = function (f) {
   }
 };
 
+Rollbar.prototype.expressMiddleware = function () {
+  return rollbarExpressMiddleware(this);
+};
+
+Rollbar.expressMiddleware = function () {
+  if (_instance) {
+    return rollbarExpressMiddleware(_instance);
+  }
+  handleUninitialized();
+  return undefined;
+};
+
 Rollbar.prototype.captureEvent = function () {
   var event = _.createTelemetryEvent(arguments);
   return this.client.captureEvent(event.type, event.metadata, event.level);

package/src/server/telemetry.js

@@ -85,6 +85,15 @@ Instrumenter.prototype.instrumentNetwork = function () {
     this.replacements,
     'network',
   );
+  if (typeof globalThis.fetch === 'function') {
+    replace(
+      globalThis,
+      'fetch',
+      fetchRequestWrapper.bind(this),
+      this.replacements,
+      'network',
+    );
+  }
 };
 
 function networkRequestWrapper(orig) {
@@ -93,10 +102,22 @@ function networkRequestWrapper(orig) {
   return (...args) => {
     const [url, options, cb] = args;
     var mergedOptions = urlHelpers.mergeOptions(url, options, cb);
+    const requestUrl = urlHelpers.constructUrl(mergedOptions.options);
+    const sessionId = _.getSessionIdFromAsyncLocalStorage(this.rollbar.client);
+
+    if (
+      sessionId &&
+      _.shouldAddBaggageHeader(this.options, { sessionId }, requestUrl)
+    ) {
+      if (!mergedOptions.options.headers) {
+        mergedOptions.options.headers = {};
+      }
+      mergedOptions.options.headers.baggage = `rollbar.session.id=${sessionId}`;
+    }
 
     var metadata = {
       method: mergedOptions.options.method || 'GET',
-      url: urlHelpers.constructUrl(mergedOptions.options),
+      url: requestUrl,
       status_code: null,
       start_time_ms: _.now(),
       end_time_ms: null,
@@ -142,6 +163,104 @@ function responseCallbackWrapper(options, metadata, callback) {
   };
 }
 
+function fetchRequestWrapper(orig) {
+  var telemeter = this.telemeter;
+
+  return (...args) => {
+    const input = args[0];
+    const init = args[1];
+    let method = 'GET';
+    let url;
+    const sessionId = _.getSessionIdFromAsyncLocalStorage(this.rollbar.client);
+
+    if (_.isType(input, 'string') || input instanceof URL) {
+      url = input.toString();
+    } else if (input) {
+      url = input.url;
+      if (input.method) {
+        method = input.method;
+      }
+    }
+
+    if (init && init.method) {
+      method = init.method;
+    }
+
+    if (
+      sessionId &&
+      _.shouldAddBaggageHeader(this.options, { sessionId }, url)
+    ) {
+      const headers = { baggage: `rollbar.session.id=${sessionId}` };
+
+      _.addHeadersToFetch(args, headers);
+    }
+
+    const metadata = {
+      method: method,
+      url: url,
+      status_code: null,
+      start_time_ms: _.now(),
+      end_time_ms: null,
+    };
+
+    if (this.autoInstrument.networkRequestHeaders) {
+      const requestHeaders = normalizeFetchHeaders(
+        init && init.headers ? init.headers : input && input.headers,
+      );
+      if (requestHeaders) {
+        metadata.request_headers = requestHeaders;
+      }
+    }
+
+    telemeter.captureNetwork(metadata, 'fetch');
+
+    return orig.apply(globalThis, args).then(
+      (res) => {
+        metadata.end_time_ms = _.now();
+        metadata.status_code = res.status;
+        if (this.autoInstrument.networkResponseHeaders) {
+          const responseHeaders = normalizeFetchHeaders(res.headers);
+          if (responseHeaders) {
+            metadata.response = metadata.response || {};
+            metadata.response.headers = responseHeaders;
+          }
+        }
+        return res;
+      },
+      (err) => {
+        metadata.end_time_ms = _.now();
+        metadata.status_code = 0;
+        metadata.error = [err.name, err.message].join(': ');
+        throw err;
+      },
+    );
+  };
+}
+
+function normalizeFetchHeaders(headers) {
+  if (!headers) return null;
+  if (typeof headers.forEach === 'function') {
+    const normalized = {};
+    headers.forEach((value, key) => {
+      normalized[key] = value;
+    });
+    return normalized;
+  }
+  if (Array.isArray(headers)) {
+    const normalized = {};
+    headers.forEach((pair) => {
+      if (pair && pair.length > 1) {
+        normalized[pair[0]] = pair[1];
+      }
+    });
+    return normalized;
+  }
+  if (_.isType(headers, 'object')) {
+    return headers;
+  }
+  return null;
+}
+
 Instrumenter.prototype.captureNetwork = function (
   metadata,
   subtype,

package/src/utility.js

@@ -146,6 +146,10 @@ function isBrowser() {
   return typeof window !== 'undefined';
 }
 
+function isRequestObject(input) {
+  return typeof Request !== 'undefined' && input instanceof Request;
+}
+
 function redact() {
   return '********';
 }
@@ -867,6 +871,69 @@ function merge() {
   return result;
 }
 
+function shouldAddBaggageHeader(options, tracing, url) {
+  if (!tracing?.sessionId || !url) {
+    return false;
+  }
+  const propagation = options?.tracing?.propagation;
+  const enabledHeaders = propagation?.enabledHeaders;
+  if (!Array.isArray(enabledHeaders) || !enabledHeaders.includes('baggage')) {
+    return false;
+  }
+  const enabledCorsUrls = propagation?.enabledCorsUrls;
+  if (!Array.isArray(enabledCorsUrls) || enabledCorsUrls.length === 0) {
+    return false;
+  }
+  return enabledCorsUrls.some((pattern) => {
+    if (isType(pattern, 'string')) {
+      return url === pattern;
+    }
+    if (isType(pattern, 'regexp')) {
+      return pattern.test(url);
+    }
+    return false;
+  });
+}
+
+function addHeadersToFetch(args, newHeaders) {
+  // Headers may be in the request object or the init object.
+  // If present in both places, the init object must be used.
+  //
+  let init = args[1];
+  const initHeaders = init?.headers;
+  const reqHeaders = isRequestObject(args[0]) && args[0].headers;
+  let headers = initHeaders || reqHeaders;
+
+  // If headers are not present in either place, they are added to the init object.
+  // If there is no init object, one must be created and added to args.
+  if (!headers) {
+    if (!init) {
+      args[1] = init = {};
+    }
+    headers = init.headers = {};
+  }
+
+  // `headers` may be a Headers object or a plain object.
+  if (headers instanceof Headers) {
+    for (const key of Object.keys(newHeaders)) {
+      headers.append(key, newHeaders[key]);
+    }
+  } else if (isObject(headers)) {
+    for (const key of Object.keys(newHeaders)) {
+      headers[key] = newHeaders[key];
+    }
+  }
+}
+
+function getSessionIdFromAsyncLocalStorage(client) {
+  const storage = client.asyncLocalStorage;
+  if (!storage || typeof storage.getStore !== 'function') {
+    return null;
+  }
+  const store = storage.getStore();
+  return store?.sessionId || null;
+}
+
 export {
   addParamsAndAccessTokenToPath,
   createItem,
@@ -902,4 +969,7 @@ export {
   maxByteSize,
   typeName,
   uuid4,
+  shouldAddBaggageHeader,
+  addHeadersToFetch,
+  getSessionIdFromAsyncLocalStorage,
 };