Init session attributes (#1326)

* span init with no session

* detect session capable window for session init

* init session attributes

Author: waltjones

src/browser/core.js

@@ -87,6 +87,8 @@ class Rollbar {
       this.instrumenter.instrument();
     }
 
+    this.setSessionAttributesFromOptions(options);
+
     // Used with rollbar-react for rollbar-react-native compatibility.
     this.rollbar = this;
   }
@@ -112,6 +114,7 @@ class Rollbar {
     if (options.logLevel) {
       logger.init({ logLevel: options.logLevel });
     }
+    this.setSessionAttributesFromOptions(options);
     var oldOptions = this.options;
     var payload = {};
     if (payloadData) {
@@ -434,6 +437,32 @@ class Rollbar {
     return this.client.captureEvent(event.type, event.metadata, event.level);
   };
 
+  setSessionUser(user) {
+    if (!this.tracing?.session) return;
+
+    this.tracing.session.setUser(user);
+  }
+
+  setSessionAttributes(attrs) {
+    if (!this.tracing?.session) return;
+
+    attrs = { ...attrs };
+
+    this.tracing.session.setAttributes(attrs);
+  }
+
+  setSessionAttributesFromOptions(options) {
+    if (options.person) {
+      this.setSessionUser(options.person);
+    }
+    const code_version = options.client?.javascript?.code_version || options.codeVersion || options.code_version;
+    this.setSessionAttributes({
+      code_version,
+      'notifier.name': 'rollbar-browser-js',
+      'notifier.version': options.version,
+    });
+  }
+
   // The following two methods are used internally and are not meant for public use
   captureDomContentLoaded(e, ts) {
     if (!ts) {

src/tracing/session.js

@@ -13,11 +13,15 @@ export class Session {
     this._attributes = {};
   }
 
-  init() {
+  init(attrs = {}) {
     if (this.session) {
       return this;
     }
-    return this.getSession() || this.createSession();
+    this.getSession() || this.createSession();
+
+    this.initSessionAttributes(attrs);
+
+    return this;
   }
 
   getSession() {
@@ -63,4 +67,26 @@ export class Session {
     this._attributes = { ...this._attributes, ...attributes };
     return this;
   }
+
+  setUser(user) {
+    this.setAttributes({
+      'user.id': user?.id,
+      'user.email': user?.email,
+      'user.name': user?.name || user?.username,
+    });
+    return this;
+  }
+
+  initSessionAttributes(attrs) {
+    this.setAttributes({
+      'session.id': this.session.id,
+      'browser.brands': navigator.userAgentData?.brands,
+      'browser.language': navigator.language,
+      'browser.mobile': navigator.userAgentData?.mobile,
+      'browser.platform': navigator.userAgentData?.platform,
+      'user_agent.original': navigator.userAgent,
+      ...attrs,
+    });
+    return this;
+  }
 }

src/tracing/span.js

@@ -23,7 +23,7 @@ export class Span {
       startTime: options.startTime || hrtime.now(options.usePerformance),
       endTime: [0, 0],
       status: { code: 0, message: '' },
-      attributes: { 'session.id': options.session.id },
+      attributes: { 'session.id': options.session?.id },
       links: [],
       events: [],
       duration: 0,

src/tracing/tracing.js

@@ -12,7 +12,9 @@ export default class Tracing {
     this.options = options;
     this.window = gWindow;
 
-    this.session = new Session(this, options);
+    if (this.window.sessionStorage) {
+      this.session = new Session(this, options);
+    }
     this.createTracer();
   }
 

test/browser.core.test.js

@@ -6,6 +6,60 @@ import { loadHtml } from './util/fixtures.js';
 
 // Use minimal browser package, with no optional components added.
 import Rollbar from '../src/browser/core.js';
+import Tracing from '../src/tracing/tracing.js';
+
+describe('options', function () {
+  beforeEach(function () {
+    Rollbar.setComponents({
+      tracing: Tracing,
+    });
+  });
+
+  afterEach(function () {
+    Rollbar.setComponents({});
+  });
+
+  it('should set session attributes from constructor', function () {
+    const rollbar = new Rollbar({
+      accessToken: 'POST_CLIENT_ITEM_TOKEN',
+      captureUnhandledRejections: false,
+      person: {
+        id: '12345',
+        name: 'Test User',
+        email: '[email protected]',
+      },
+      codeVersion: 'abc123',
+    });
+    const session = rollbar.tracing.session;
+    expect(session).to.exist;
+    expect(session.attributes['user.id']).to.equal('12345');
+    expect(session.attributes['user.name']).to.equal('Test User');
+    expect(session.attributes['user.email']).to.equal('[email protected]');
+    expect(session.attributes['code_version']).to.equal('abc123');
+  });
+
+  it('should set session attributes from configure', function () {
+    const rollbar = new Rollbar({
+      accessToken: 'POST_CLIENT_ITEM_TOKEN',
+      captureUnhandledRejections: false,
+
+    });
+    rollbar.configure({
+      person: {
+        id: '12345',
+        name: 'Test User',
+        email: '[email protected]',
+      },
+      codeVersion: 'abc123',
+    });
+    const session = rollbar.tracing.session;
+    expect(session).to.exist;
+    expect(session.attributes['user.id']).to.equal('12345');
+    expect(session.attributes['user.name']).to.equal('Test User');
+    expect(session.attributes['user.email']).to.equal('[email protected]');
+    expect(session.attributes['code_version']).to.equal('abc123');
+  });
+});
 
 describe('options.captureUncaught', function () {
   let __originalOnError = null;

test/replay/integration/e2e.test.js

@@ -168,7 +168,7 @@ describe('Session Replay E2E', function () {
           expect(span_r).to.have.property('events');
           expect(span_r.events).to.be.an('array');
           expect(span_r).to.have.property('attributes').that.is.an('array');
-          expect(span_r.attributes).to.have.lengthOf(4);
+          expect(span_r.attributes).to.have.lengthOf(9);
 
           expect(span_r.attributes).to.deep.include({
             key: 'rollbar.replay.id',
@@ -182,6 +182,22 @@ describe('Session Replay E2E', function () {
             key: 'user.email',
             value: { stringValue: '[email protected]' },
           });
+          expect(span_r.attributes).to.deep.include({
+            key: 'browser.mobile',
+            value: { boolValue: false },
+          });
+
+          const languageAttr = span_r.attributes.find(
+            (attr) => attr.key === 'browser.language',
+          );
+          expect(languageAttr).to.exist;
+          expect(languageAttr.value.stringValue).to.match(/en-US/);
+
+          const userAgentAttr = span_r.attributes.find(
+            (attr) => attr.key === 'user_agent.original',
+          );
+          expect(userAgentAttr).to.exist;
+          expect(userAgentAttr.value.stringValue).to.match(/HeadlessChrome/);
 
           const sessionIdAttr = span_r.attributes.find(
             (attr) => attr.key === 'session.id',

test/tracing/span.test.js

@@ -166,6 +166,14 @@ describe('Span()', function () {
     done();
   });
 
+  it('should create a readable span without a session present', function (done) {
+    const span = new Span(spanOptions({ session: undefined }));
+
+    expectReadableSpan(span, {attributes: { 'session.id': undefined }});
+
+    done();
+  });
+
   it('should keep valid state', function (done) {
     const span = new Span(spanOptions());
     expect(span.isRecording()).to.be.true;

test/tracing/tracing.test.js

@@ -1,4 +1,5 @@
 import { expect } from 'chai';
+import sinon from 'sinon';
 
 import {
   ContextManager,
@@ -107,13 +108,25 @@ describe('Tracing()', function () {
       'user.email': '[email protected]',
     });
 
-    expect(t.session.attributes).to.deep.equal({
+    expect(t.session.attributes).to.deep.include({
       codeVersion: 'abc123',
       'user.id': '12345',
       'user.email': '[email protected]',
     });
   });
 
+  it('should not init session when sessionStorage is not detected', function () {
+    const stub = sinon.stub(window, 'sessionStorage').value(undefined);
+    const options = tracingOptions();
+    const t = new Tracing(window, options);
+
+    // calling initSession should be a no-op
+    t.initSession();
+
+    expect(t.session).to.be.undefined;
+    stub.restore();
+  });
+
   it('should generate ids', function (done) {
     const options = tracingOptions();
     const t = new Tracing(window, options);