Merge pull request #38 from launchdarkly/ag/ch15259/add-flush-method

[ch15259] Add flush method

Author: apucacao

src/EventProcessor.js

@@ -1,5 +1,43 @@
 var utils = require('./utils');
 
+var MAX_URL_LENGTH = 2000;
+var hasCors = 'withCredentials' in new XMLHttpRequest();
+
+function sendEvents(eventsUrl, events, sync) {
+  var src = eventsUrl + '?d=' + utils.base64URLEncode(JSON.stringify(events));
+  
+  var send = function(onDone) {
+    // Detect browser support for CORS
+    if (hasCors) {
+      /* supports cross-domain requests */
+      var xhr = new XMLHttpRequest();
+      xhr.open('GET', src, !sync);
+
+      if (!sync) {
+        xhr.addEventListener('load', onDone);
+      }
+
+      xhr.send();
+    } else {
+      var img = new Image();
+
+      if (!sync) {
+        img.addEventListener('load', onDone);
+      }
+
+      img.src = src;
+    }
+  }
+
+  if (sync) {
+    send();
+  } else {
+    return new Promise(function(resolve) {
+      send(resolve);
+    });
+  }
+}
+
 function EventProcessor(eventsUrl, eventSerializer) {
   var processor = {};
   var queue = [];
@@ -8,63 +46,35 @@ function EventProcessor(eventsUrl, eventSerializer) {
   processor.enqueue = function(event) {
     queue.push(event);
   };
-  
+
   processor.flush = function(user, sync) {
-    var maxLength = 2000 - eventsUrl.length;
-    var data = [];
-    
+    var finalSync = sync === undefined ? false : sync;
+    var serializedQueue = eventSerializer.serialize_events(queue);
+    var chunks;
+    var results = [];
+
     if (!user) {
       if (initialFlush) {
         console && console.warn && console.warn('Be sure to call `identify` in the LaunchDarkly client: http://docs.launchdarkly.com/docs/running-an-ab-test#include-the-client-side-snippet');
       }
-      return false;
+      return Promise.resolve();
     }
 
     initialFlush = false;
-    while (maxLength > 0 && queue.length > 0) {
-      var event = queue.pop();
-      event.user = user;
-      maxLength = maxLength - utils.base64URLEncode(JSON.stringify(event)).length;
-      // If we are over the max size, put this one back on the queue
-      // to try in the next round, unless this event alone is larger 
-      // than the limit, in which case, screw it, and try it anyway.
-      if (maxLength < 0 && data.length > 0) {
-        queue.push(event);
-      } else {
-        data.push(event);
-      }
+
+    if (serializedQueue.length === 0) {
+      return Promise.resolve();
     }
+
+    chunks = utils.chunkUserEventsForUrl(MAX_URL_LENGTH - eventsUrl.length, serializedQueue);
 
-    if (data.length > 0) {
-      data = eventSerializer.serialize_events(data);
-      var src = eventsUrl + '?d=' + utils.base64URLEncode(JSON.stringify(data));
-      //Detect browser support for CORS
-      if ('withCredentials' in new XMLHttpRequest()) {
-        /* supports cross-domain requests */
-        var xhr = new XMLHttpRequest();
-        xhr.open('GET', src, !sync);
-        xhr.send();
-      } else {
-        var img = new Image();
-        img.src = src;
-      }
+    for (var i=0 ; i < chunks.length ; i++) {
+      results.push(sendEvents(eventsUrl, chunks[i], finalSync));
     }
 
-    // if the queue is not empty, call settimeout to flush it again 
-    // with a 0 timeout (stack-less recursion)
-    // Or, just recursively call flush_queue with the remaining elements
-    // if we're doing this on unload
-    if (queue.length > 0) {
-      if (sync) {
-        processor.flush(user, sync);
-      }
-      else {
-        setTimeout(function() {
-          processor.flush(user);
-        }, 0);
-      }
-    }
-    return false;
+    queue = [];
+
+    return sync ? Promise.resolve() : Promise.all(results);
   };
 
   return processor;

src/__tests__/EventProcessor-test.js

@@ -0,0 +1,67 @@
+var EventSerializer = require('../EventSerializer');
+var EventProcessor = require('../EventProcessor');
+
+describe('EventProcessor', function() {
+  var sandbox;
+  var xhr;
+  var requests = [];
+  var serializer = EventSerializer({});
+
+  beforeEach(function() {
+    sandbox = sinon.sandbox.create();
+    requests = [];
+    xhr = sinon.useFakeXMLHttpRequest();
+    xhr.onCreate = function(xhr) {
+      requests.push(xhr);
+    };
+  })
+
+  afterEach(function() {
+    sandbox.restore();
+    xhr.restore();
+  })
+
+  it('should warn about missing user on initial flush', function() {
+    var warnSpy = sandbox.spy(console, 'warn');
+    var processor = EventProcessor('/fake-url', serializer);
+    processor.flush(null);
+    warnSpy.restore();
+    expect(warnSpy.called).to.be.true;
+  })
+
+  it('should flush asynchronously', function() {
+    var processor = EventProcessor('/fake-url', serializer);
+    var user = {key: 'foo'};
+    var event = {kind: 'identify', key: user.key};
+    var result;
+    
+    processor.enqueue(event);
+    processor.enqueue(event);
+    processor.enqueue(event);
+    processor.enqueue(event);
+
+    result = processor.flush(user);
+    requests[0].respond();
+
+    expect(requests.length).to.equal(1);
+    expect(requests[0].async).to.be.true;
+  });
+
+  it('should flush synchronously', function() {
+    var processor = EventProcessor('/fake-url', serializer);
+    var user = {key: 'foo'};
+    var event = {kind: 'identify', key: user.key};
+    var result;
+    
+    processor.enqueue(event);
+    processor.enqueue(event);
+    processor.enqueue(event);
+    processor.enqueue(event);
+
+    result = processor.flush(user, true);
+    requests[0].respond();
+
+    expect(requests.length).to.equal(1);
+    expect(requests[0].async).to.be.false;
+  });
+})

src/__tests__/utils-test.js

@@ -1,5 +1,7 @@
 var assert = require('assert');
-var wrapPromiseCallback = require('../utils.js').wrapPromiseCallback;
+var utils = require('../utils.js');
+var wrapPromiseCallback = utils.wrapPromiseCallback;
+var chunkUserEventsForUrl = utils.chunkUserEventsForUrl;
 
 describe('utils', function() {
   describe('wrapPromiseCallback', function() {
@@ -49,4 +51,15 @@ describe('utils', function() {
       });
     });
   });
+
+  describe('chunkUserEventsForUrl', function() {
+    it('should properly chunk the list of events', function() {
+      var user = {key: 'foo'};
+      var event = {kind: 'identify', key: user.key};
+      var eventLength = utils.base64URLEncode(JSON.stringify(event)).length;
+      var events = [event,event,event,event,event];
+      var chunks = chunkUserEventsForUrl(eventLength * 2, events);
+      expect(chunks).to.eql([[event, event],[event,event],[event]]);
+    })
+  })
 });

src/index.d.ts

@@ -206,6 +206,14 @@ declare module 'ldclient-js' {
      */
     identify: (user: LDUser, hash?: string, onDone?: () => void) => Promise<void>;
 
+    /**
+     * Flushes pending events asynchronously.
+     * 
+     * @param onDone
+     *   A callback to invoke after the events were flushed.
+     */
+    flush: (onDone?: Function) => Promise<void>;
+
     /**
      * Retrieves a flag's value.
      *

src/index.js

@@ -73,6 +73,7 @@ function initialize(env, user, options) {
       key: goal.key,
       data: null,
       url: window.location.href,
+      user: ident.getUser(),
       creationDate: (new Date()).getTime()
     };
 
@@ -99,6 +100,12 @@ function initialize(env, user, options) {
     }).bind(this)), onDone);
   }
 
+  function flush(onDone) {
+    return utils.wrapPromiseCallback(new Promise(function(resolve) {
+      return sendEvents ? resolve(events.flush(ident.getUser())) : resolve();
+    }.bind(this), onDone));
+  }
+
   function variation(key, defaultValue) {
     var value;
 
@@ -407,6 +414,7 @@ function initialize(env, user, options) {
     track: track,
     on: on,
     off: off,
+    flush: flush,
     allFlags: allFlags
   };
 

src/utils.js

@@ -91,12 +91,51 @@ function wrapPromiseCallback(promise, callback) {
   );
 }
 
+/**
+ * Returns an array of event groups each of which can be safely URL-encoded
+ * without hitting the safe maximum URL length of certain browsers.
+ * 
+ * @param {number} maxLength maximum URL length targeted
+ * @param {Array[Object}]} events queue of events to divide
+ * @returns Array[Array[Object]]
+ */
+function chunkUserEventsForUrl(maxLength, events) {
+  var allEvents = events.slice(0);
+  var remainingSpace = maxLength;
+  var allChunks = [];
+  var chunk;
+
+  while (allEvents.length > 0) {
+    chunk = [];
+
+    while (remainingSpace > 0) {
+      var event = allEvents.pop();
+      if (!event) { break; }
+      remainingSpace = remainingSpace - base64URLEncode(JSON.stringify(event)).length;
+      // If we are over the max size, put this one back on the queue
+      // to try in the next round, unless this event alone is larger 
+      // than the limit, in which case, screw it, and try it anyway.
+      if (remainingSpace < 0 && chunk.length > 0) {
+        allEvents.push(event);
+      } else {
+        chunk.push(event);
+      }
+    }
+
+    remainingSpace = maxLength;
+    allChunks.push(chunk);
+  }
+
+  return allChunks;
+}
+
 module.exports = {
   btoa: btoa,
   base64URLEncode: base64URLEncode,
   clone: clone,
   modifications: modifications,
   merge: merge,
   onNextTick: onNextTick,
-  wrapPromiseCallback: wrapPromiseCallback
+  wrapPromiseCallback: wrapPromiseCallback,
+  chunkUserEventsForUrl: chunkUserEventsForUrl
 };