Make a nicer interface for token loading

Author: imbstack

src/client.js

@@ -11,21 +11,28 @@ class StatsumClient extends events.EventEmitter {
   /**
    * Create a statsum client.
    *
-   * Óptions:
+   * Configurer: A function that returns an object like
    * ```js
    * {
    *   project:       '...',                  // Project to submit for
-   *   token:         '...',                  // JWT token (if not getToken)
-   *   getToken:      () => {token, expires}, // Async function for token
+   *   token:         '...',                  // JWT token
    *   baseUrl:       'https://example.com/', // baseUrl for the server
+   *   expires:       'date-time',            // Time at which the token expires
+   * }
+   * ```
+   *
+   * Options:
+   * ```js
+   * {
+   *   project:       '...',                  // Project to submit for
    *   maxDataPoints: 10000,                  // Max data-points before flushing
    *   maxDelay:      90,                     // Max delay before flush (s)
    *   minDelay:      30,                     // Min delay before flush (s)
    *   emitErrors:    false,                  // Emit 'error' events on errors
    * }
    * ```
    */
-  constructor(options) {
+  constructor(configurer, options) {
     super();
     this._options = options = _.defaults({}, options || {}, {
       maxDataPoints:  10000,
@@ -34,9 +41,6 @@ class StatsumClient extends events.EventEmitter {
       emitErrors:     false,
     });
     assert(options.project, 'project is required');
-    assert(options.token || options.getToken instanceof Function,
-           'token or getToken is required');
-    assert(options.baseUrl, 'baseUrl is required');
     assert(typeof(options.minDelay) === 'number', 'minDelay must be a number');
     assert(typeof(options.maxDelay) === 'number', 'maxDelay must be a number');
     assert(options.maxDelay >= 30, 'maxDelay must be > 30 seconds');
@@ -47,6 +51,7 @@ class StatsumClient extends events.EventEmitter {
     this._measures = {};
     this._flushTimer = null;
     this._dataPoints = 0;
+    this._configurer = configurer;
   }
 
   /** Increment counter for `key` with `count` */
@@ -110,7 +115,7 @@ class StatsumClient extends events.EventEmitter {
         dataPoints, payload.counters.length + payload.measures.length,
         this._options.project,
       );
-      await sendDataPoints(this._options, payload);
+      await sendDataPoints(this._configurer, this._options, payload);
     } catch (err) {
       debug('Failed to send data-points with error: %s, stack: %j', err, err);
       if (this._options.emitErrors) {

src/send.js

@@ -1,3 +1,4 @@
+let assert  = require('assert');
 let urljoin = require('url-join');
 let got     = require('got');
 let debug   = require('debug')('statsum');
@@ -23,19 +24,16 @@ if (msgpack) {
 }
 
 /** Send data-point to statsum */
-let sendDataPoints = async (options, payload) => {
-  // Get authentication token
-  let token = options.token;
-  if (!token || options.tokenExpires < new Date()) {
-    // If we have one, or it's expired, we get a new one
-    let result = await options.getToken();
-    if (!result.token || !result.expires) {
-      let err = new Error('getToken() must return {token, expires}');
-      err.result = result;
-      throw err;
-    }
+let sendDataPoints = async (configurer, options, payload) => {
+
+  if (!options.token || options.tokenExpires < new Date()) {
+    let result = await configurer(options.project);
+    assert(result.token, 'token is required from the configurer');
+    assert(result.baseUrl, 'baseUrl is required from the configurer');
+    assert(result.expires, 'expires is required from the configurer');
     options.token = result.token;
     options.tokenExpires = new Date(result.expires);
+    options.baseUrl = result.baseUrl;
   }
 
   let url = urljoin(options.baseUrl, 'v1/project', options.project);

test/statsum_test.js

@@ -17,9 +17,11 @@ suite('statsum', () => {
     deserialize = (data) => msgpack.unpack(data);
   }
 
+
   let server = null;
   let baseUrl = null;
   let payload = null;
+  let configurer = null;
   before(async () => {
     server = http.createServer();
     server.on('request', async (req, res) => {
@@ -37,6 +39,13 @@ suite('statsum', () => {
       server.listen();
     });
     baseUrl = 'http://localhost:' + server.address().port;
+
+    configurer = async (project) => { return {
+      project,
+      baseUrl,
+      token: 'KEY',
+      expires: new Date().toJSON()
+    }};
   });
   after(async () => {
     server.close();
@@ -50,30 +59,8 @@ suite('statsum', () => {
     assert(result.exp > Date.now() / 1000 + 60);
   });
 
-  test('getToken', async () => {
-    let getTokenCalls = 0;
-    let delay = 0;
-    let statsum = new Statsum({project: 'test', getToken() {
-      getTokenCalls +=1;
-      return new Promise({token: 'KEY', expires: new Date(Date.now() + delay)});
-    }, baseUrl});
-
-    statsum.count('my-counter', 10);
-    assert(getTokenCalls === 0);
-    await statsum.flush();
-    await new Promise(accept => setTimeout(accept, 100));
-    assert(getTokenCalls === 1);
-
-    delay = 500;
-    statsum.count('my-counter', 10);
-    await statsum.flush();
-    assert(getTokenCalls === 2);
-    await new Promise(accept => setTimeout(accept, 100));
-    assert(getTokenCalls === 2);
-  });
-
   test('count()', async () => {
-    let statsum = new Statsum({project: 'test', token: 'KEY', baseUrl});
+    let statsum = new Statsum(configurer, {project: 'test'});
 
     statsum.count('my-counter', 10);
     await statsum.flush();
@@ -94,7 +81,7 @@ suite('statsum', () => {
   });
 
   test('value()', async () => {
-    let statsum = new Statsum({project: 'test', token: 'KEY', baseUrl});
+    let statsum = new Statsum(configurer, {project: 'test'});
 
     statsum.measure('my-timer', 10);
     await statsum.flush();
@@ -118,7 +105,7 @@ suite('statsum', () => {
   });
 
   test('value() w. tags', async () => {
-    let statsum = new Statsum({project: 'test', token: 'KEY', baseUrl});
+    let statsum = new Statsum(configurer, {project: 'test'});
 
     statsum.measure({tag1: 'v1', tag2: 'v2'}, 5);
     statsum.measure({tag1: 'v1', tag2: 'v1'}, 5);
@@ -142,7 +129,7 @@ suite('statsum', () => {
   });
 
   test('prefix().count()', async () => {
-    let statsum = new Statsum({project: 'test', token: 'KEY', baseUrl});
+    let statsum = new Statsum(configurer, {project: 'test'});
     statsum = statsum.prefix('my')
 
     statsum.count('counter', 10);
@@ -164,7 +151,7 @@ suite('statsum', () => {
   });
 
   test('prefix().measure()', async () => {
-    let statsum = new Statsum({project: 'test', token: 'KEY', baseUrl});
+    let statsum = new Statsum(configurer, {project: 'test'});
     statsum = statsum.prefix('my')
 
     statsum.measure('timer', 10);
@@ -189,7 +176,7 @@ suite('statsum', () => {
   });
 
   test('prefix().prefix()', async () => {
-    let statsum = new Statsum({project: 'test', token: 'KEY', baseUrl});
+    let statsum = new Statsum(configurer, {project: 'test'});
     statsum = statsum.prefix('my').prefix('count');
 
     statsum.count('2', 10);
@@ -201,4 +188,4 @@ suite('statsum', () => {
     assert(payload.counters[0].k === 'my.count.2', 'missing my.count.2');
     assert(payload.counters[0].v === 12, 'wrong count');
   });
-});
+});