rudder-sdk-js 2.14.0 → 2.15.0

package/index.d.ts

@@ -89,6 +89,10 @@ declare module "rudder-sdk-js" {
     anonymousIdOptions?: anonymousIdOptions;
     // defaults to https://cdn.rudderlabs.com/v1.1/js-integrations
     destSDKBaseURL?: string;
+    sessions?: {
+      autoTrack?: boolean; // Defaults to true
+      timeout?: number; // Defaults to 30 mins
+    }
   }
 
   /**
@@ -452,6 +456,16 @@ declare module "rudder-sdk-js" {
    */
   function getGroupTraits(): apiObject;
 
+  /**
+   * To manually start user session in the SDK
+   */
+   function startSession(sessionId?: number): void;
+
+   /**
+   * To manually end user session in the SDK
+   */
+   function endSession(): void;
+
   export {
     integrationOptions,
     loadOptions,
@@ -474,5 +488,7 @@ declare module "rudder-sdk-js" {
     getUserTraits,
     getGroupId,
     getGroupTraits,
+    startSession,
+    endSession,
   };
 }

package/index.js

@@ -5016,7 +5016,7 @@
 
   // Reserved Keywords for properties/traits
   var RESERVED_KEYS = ['anonymous_id', 'id', 'sent_at', 'received_at', 'timestamp', 'original_timestamp', 'event_text', 'event'];
-  var CONFIG_URL = 'https://api.rudderlabs.com/sourceConfig/?p=npm&v=2.14.0';
+  var CONFIG_URL = 'https://api.rudderlabs.com/sourceConfig/?p=npm&v=2.15.0';
   var CDN_INT_DIR = 'js-integrations';
   var DEST_SDK_BASE_URL = "https://cdn.rudderlabs.com/v1.1/".concat(CDN_INT_DIR);
   var MAX_WAIT_FOR_INTEGRATION_LOAD = 10000;
@@ -5026,6 +5026,11 @@
   var DEFAULT_ERROR_REPORT_PROVIDER = 'bugsnag';
   var ERROR_REPORT_PROVIDERS = [DEFAULT_ERROR_REPORT_PROVIDER];
   var SAMESITE_COOKIE_OPTS = ['Lax', 'None', 'Strict'];
+  var DEFAULT_SESSION_TIMEOUT = 30 * 60 * 1000; // 30 min in milliseconds
+
+  var MIN_SESSION_TIMEOUT = 10 * 1000; // 10 sec in milliseconds
+
+  var MIN_SESSION_ID_LENGTH = 10;
 
   var aes = {exports: {}};
 
@@ -9892,6 +9897,7 @@
     group_storage_trait: 'rl_group_trait',
     page_storage_init_referrer: 'rl_page_init_referrer',
     page_storage_init_referring_domain: 'rl_page_init_referring_domain',
+    session_info: 'rl_session',
     prefix: 'RudderEncrypt:',
     key: 'Rudder'
   };
@@ -10088,6 +10094,16 @@
       value: function setInitialReferringDomain(value) {
         this.setItem(defaults$1.page_storage_init_referring_domain, value);
       }
+      /**
+       * Set session information
+       * @param {*} value
+       */
+
+    }, {
+      key: "setSessionInfo",
+      value: function setSessionInfo(value) {
+        this.setItem(defaults$1.session_info, value);
+      }
       /**
        *
        * @param {*} key
@@ -10250,6 +10266,15 @@
       value: function getInitialReferringDomain() {
         return this.getItem(defaults$1.page_storage_init_referring_domain);
       }
+      /**
+       * get the stored session info
+       */
+
+    }, {
+      key: "getSessionInfo",
+      value: function getSessionInfo() {
+        return this.getItem(defaults$1.session_info);
+      }
       /**
        *
        * @param {*} key
@@ -10260,6 +10285,11 @@
       value: function removeItem(key) {
         return this.storage.remove(key);
       }
+    }, {
+      key: "removeSessionInfo",
+      value: function removeSessionInfo() {
+        this.removeItem(defaults$1.session_info);
+      }
       /**
        * remove stored keys
        */
@@ -10661,6 +10691,10 @@
     };
   };
 
+  var countDigits = function countDigits(number) {
+    return number ? number.toString().length : 0;
+  };
+
   // Application class
   var RudderApp = /*#__PURE__*/_createClass(function RudderApp() {
     _classCallCheck(this, RudderApp);
@@ -10668,7 +10702,7 @@
     this.build = '1.0.0';
     this.name = 'RudderLabs JavaScript SDK';
     this.namespace = 'com.rudderlabs.javascript';
-    this.version = '2.14.0';
+    this.version = '2.15.0';
   });
 
   /* eslint-disable max-classes-per-file */
@@ -10677,7 +10711,7 @@
     _classCallCheck(this, RudderLibraryInfo);
 
     this.name = 'RudderLabs JavaScript SDK';
-    this.version = '2.14.0';
+    this.version = '2.15.0';
   }); // Operating System information class
 
 
@@ -13352,7 +13386,7 @@
     var devHosts = ['localhost', '127.0.0.1', '[::1]'];
     window.rsBugsnagClient = window.Bugsnag.start({
       apiKey: API_KEY,
-      appVersion: '2.14.0',
+      appVersion: '2.15.0',
       // Set SDK version as the app version
       metadata: META_DATA,
       onError: function onError(event) {
@@ -13416,6 +13450,226 @@
     }
   };
 
+  var UserSession = /*#__PURE__*/function () {
+    function UserSession() {
+      _classCallCheck(this, UserSession);
+
+      this.storage = Storage;
+      this.timeout = DEFAULT_SESSION_TIMEOUT;
+      this.sessionInfo = {
+        autoTrack: true
+      };
+    }
+    /**
+     * A function to initialize session information
+     * @param {object} options    load call options
+     */
+
+
+    _createClass(UserSession, [{
+      key: "initialize",
+      value: function initialize(options) {
+        try {
+          var _options$sessions;
+
+          // Fetch session information from storage if any or initialize with an empty object
+          this.sessionInfo = this.storage.getSessionInfo() || this.sessionInfo;
+          /**
+           * By default this.autoTrack will be true
+           * Cases where this.autoTrack will be false:
+           * 1. User explicitly set autoTrack load option to false
+           * 2. When user is manually tracking the session
+           *
+           * Depending on the use case, this.autoTrack is set to true/false.
+           */
+
+          this.sessionInfo.autoTrack = !((options === null || options === void 0 ? void 0 : (_options$sessions = options.sessions) === null || _options$sessions === void 0 ? void 0 : _options$sessions.autoTrack) === false || this.sessionInfo.manualTrack);
+          /**
+           * Validate "timeout" input. Should be provided in milliseconds.
+           * Session timeout: By default, a session lasts until there's 30 minutes of inactivity,
+           * but you can configure this limit using "timeout" load option
+           */
+
+          if (options !== null && options !== void 0 && options.sessions && !isNaN(options.sessions.timeout)) {
+            var timeout = options.sessions.timeout; // In case user provides 0 as the timeout, auto session tracking will be disabled
+
+            if (timeout === 0) {
+              logger.warn('[Session]:: Provided timeout value 0 will disable the auto session tracking feature.');
+              this.sessionInfo.autoTrack = false;
+            } // In case user provides a setTimeout value greater than 0 but less than 10 seconds SDK will show a warning
+            // and will proceed with it
+
+
+            if (timeout > 0 && timeout < MIN_SESSION_TIMEOUT) {
+              logger.warn('[Session]:: It is not advised to set "timeout" less than 10 seconds');
+            }
+
+            this.timeout = timeout;
+          } // If auto session tracking is enabled start the session tracking
+
+
+          if (this.sessionInfo.autoTrack) {
+            this.startAutoTracking();
+          } else if (this.sessionInfo.autoTrack === false && !this.sessionInfo.manualTrack) {
+            /**
+             * Use case:
+             * By default user session is enabled which means storage will have session data.
+             * In case user wanted to opt out and set auto track to false through load option,
+             * clear stored session info.
+             */
+            this.end();
+          }
+        } catch (e) {
+          handleError(e);
+        }
+      }
+      /**
+       * A function to validate current session and return true/false depending on that
+       * @param {number} timestamp
+       * @returns boolean
+       */
+
+    }, {
+      key: "isValidSession",
+      value: function isValidSession(timestamp) {
+        return timestamp <= this.sessionInfo.expiresAt;
+      }
+      /**
+       * A function to generate session id
+       * @returns number
+       */
+
+    }, {
+      key: "generateSessionId",
+      value: function generateSessionId() {
+        return Date.now();
+      }
+      /**
+       * A function to check for existing session details and depending on that create a new session.
+       */
+
+    }, {
+      key: "startAutoTracking",
+      value: function startAutoTracking() {
+        var timestamp = Date.now();
+
+        if (!this.isValidSession(timestamp)) {
+          this.sessionInfo = {};
+          this.sessionInfo.id = timestamp; // set the current timestamp
+
+          this.sessionInfo.expiresAt = timestamp + this.timeout; // set the expiry time of the session
+
+          this.sessionInfo.sessionStart = true;
+          this.sessionInfo.autoTrack = true;
+        }
+
+        this.storage.setSessionInfo(this.sessionInfo);
+      }
+      /**
+       * Function to validate user provided sessionId
+       * @param {number} sessionId
+       * @returns
+       */
+
+    }, {
+      key: "validateSessionId",
+      value: function validateSessionId(sessionId) {
+        if (typeof sessionId !== 'number' || sessionId % 1 !== 0) {
+          logger.error("[Session]:: \"sessionId\" should only be a positive integer");
+          return;
+        }
+
+        if (countDigits(sessionId) < MIN_SESSION_ID_LENGTH) {
+          logger.error("[Session]:: \"sessionId\" should at least be \"".concat(MIN_SESSION_ID_LENGTH, "\" digits long"));
+          return;
+        }
+
+        return sessionId;
+      }
+      /**
+       * A public method to start a session
+       * @param {number} sessionId     session identifier
+       * @returns
+       */
+
+    }, {
+      key: "start",
+      value: function start(id) {
+        var sessionId = id ? this.validateSessionId(id) : this.generateSessionId();
+        this.sessionInfo = {
+          id: sessionId || this.generateSessionId(),
+          sessionStart: true,
+          manualTrack: true
+        };
+        this.storage.setSessionInfo(this.sessionInfo);
+      }
+      /**
+       * A public method to end an ongoing session.
+       */
+
+    }, {
+      key: "end",
+      value: function end() {
+        this.sessionInfo = {};
+        this.storage.removeSessionInfo();
+      }
+      /**
+       * A function get ongoing sessionId.
+       */
+
+    }, {
+      key: "getSessionInfo",
+      value: function getSessionInfo() {
+        var session = {};
+
+        if (this.sessionInfo.autoTrack || this.sessionInfo.manualTrack) {
+          // renew or create a new auto-tracking session
+          if (this.sessionInfo.autoTrack) {
+            var timestamp = Date.now();
+
+            if (!this.isValidSession(timestamp)) {
+              this.startAutoTracking();
+            } else {
+              this.sessionInfo.expiresAt = timestamp + this.timeout; // set the expiry time of the session
+            }
+          }
+
+          if (this.sessionInfo.sessionStart) {
+            session.sessionStart = true;
+            this.sessionInfo.sessionStart = false;
+          }
+
+          session.sessionId = this.sessionInfo.id;
+          this.storage.setSessionInfo(this.sessionInfo);
+        }
+
+        return session;
+      }
+      /**
+       * Refresh session info on reset API call
+       */
+
+    }, {
+      key: "reset",
+      value: function reset() {
+        var _this$sessionInfo = this.sessionInfo,
+            manualTrack = _this$sessionInfo.manualTrack,
+            autoTrack = _this$sessionInfo.autoTrack;
+
+        if (autoTrack) {
+          this.sessionInfo = {};
+          this.startAutoTracking();
+        } else if (manualTrack) {
+          this.start();
+        }
+      }
+    }]);
+
+    return UserSession;
+  }();
+
+  var userSession = new UserSession();
+
   /**
    * class responsible for handling core
    * event tracking functionalities
@@ -13455,6 +13709,7 @@
       this.logLevel = undefined; // flag to indicate client integrations` ready status
 
       this.clientIntegrationsReady = false;
+      this.uSession = userSession;
     }
     /**
      * initialize the user after load config
@@ -14042,6 +14297,18 @@
             if (this.groupTraits) {
               rudderElement.message.traits = _objectSpread2({}, this.groupTraits);
             }
+          } // If auto/manual session tracking is enabled sessionId will be sent in the context
+
+
+          try {
+            var _this$uSession$getSes = this.uSession.getSessionInfo(),
+                sessionId = _this$uSession$getSes.sessionId,
+                sessionStart = _this$uSession$getSes.sessionStart;
+
+            rudderElement.message.context.sessionId = sessionId;
+            if (sessionStart) rudderElement.message.context.sessionStart = true;
+          } catch (e) {
+            handleError(e);
           }
 
           this.processOptionsParam(rudderElement, options); // logger.debug(JSON.stringify(rudderElement))
@@ -14220,6 +14487,7 @@
         this.userTraits = {};
         this.groupId = '';
         this.groupTraits = {};
+        this.uSession.reset();
         this.storage.clear(flag);
       }
     }, {
@@ -14360,7 +14628,10 @@
 
         if (options && options.sendAdblockPageOptions && _typeof(options.sendAdblockPageOptions) === 'object') {
           this.sendAdblockPageOptions = options.sendAdblockPageOptions;
-        }
+        } // Session initialization
+
+
+        this.uSession.initialize(options);
 
         if (options && options.clientSuppliedCallbacks) {
           // convert to rudder recognized method names
@@ -14548,6 +14819,26 @@
       value: function sendSampleRequest() {
         ScriptLoader('ad-block', '//pagead2.googlesyndication.com/pagead/js/adsbygoogle.js');
       }
+      /**
+       * A public method to start a session
+       * @param {string} sessionId     session identifier
+       * @returns
+       */
+
+    }, {
+      key: "startSession",
+      value: function startSession(sessionId) {
+        this.uSession.start(sessionId);
+      }
+      /**
+       * A public method to end an ongoing session.
+       */
+
+    }, {
+      key: "endSession",
+      value: function endSession() {
+        this.uSession.end();
+      }
     }]);
 
     return Analytics;
@@ -14654,8 +14945,11 @@
   var setAnonymousId = instance.setAnonymousId.bind(instance);
   var getGroupId = instance.getGroupId.bind(instance);
   var getGroupTraits = instance.getGroupTraits.bind(instance);
+  var startSession = instance.startSession.bind(instance);
+  var endSession = instance.endSession.bind(instance);
 
   exports.alias = alias;
+  exports.endSession = endSession;
   exports.getAnonymousId = getAnonymousId;
   exports.getGroupId = getGroupId;
   exports.getGroupTraits = getGroupTraits;
@@ -14669,6 +14963,7 @@
   exports.ready = ready;
   exports.reset = reset;
   exports.setAnonymousId = setAnonymousId;
+  exports.startSession = startSession;
   exports.track = track;
 
   Object.defineProperty(exports, '__esModule', { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rudder-sdk-js",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "description": "RudderStack Javascript SDK",
   "main": "index.js",
   "types": "index.d.ts",