Merge pull request #18 from statful/validate-values

fix(TEL-NA): validate metric values, usage of ES6 methods to simplify…

Author: jmtavares

dist/statful.js

@@ -17,22 +17,22 @@ export default class Metric {
             typeAggregationFrequency = config[type].aggregationFrequency;
         }
 
-        this.tags = this.setTags(options.tags, config.tags, typeTags, config.app);
-        this.aggregations = this.setAggregations(options.aggregations, config.aggregations, typeAggregations);
-        this.aggregationFrequency = this.setAggregationFrequency(options.aggregationFrequency, config.aggregationFrequency, typeAggregationFrequency);
+        this.tags = this.buildTags(options.tags, config.tags, typeTags, config.app);
+        this.aggregations = this.buildAggregations(options.aggregations, config.aggregations, typeAggregations);
+        this.aggregationFrequency = this.buildAggregationFrequency(options.aggregationFrequency, config.aggregationFrequency, typeAggregationFrequency);
         this.namespace = options.namespace || config.namespace;
         this.sampleRate = options.sampleRate || config.sampleRate;
     }
 
     /**
-     * Define tags for a metric type
+     * Build tags for a metric type
      * @param {object} methodTags - list of method tags
      * @param {object} globalTags - list of global tags
      * @param {object} typeTags - list of type tags
      * @param {string} app - app tag value
      * @returns {*}
      */
-    setTags(methodTags = {}, globalTags = {}, typeTags = {}, app) {
+    buildTags(methodTags = {}, globalTags = {}, typeTags = {}, app) {
         let tags = {};
 
         Object.assign(tags, globalTags);
@@ -47,15 +47,16 @@ export default class Metric {
     }
 
     /**
-     * Define aggregations for a metric type
+     * Build aggregations for a metric type
      * @param {Array} methodAggregations - list of method aggregations
      * @param {Array} globalAggregations - list of global aggregations
      * @param {Array} typeAggregations - list of type aggregations
      * @returns {*|Array}
      */
-    setAggregations(methodAggregations = [], globalAggregations = [], typeAggregations = []) {
-        let aggregations = globalAggregations;
+    buildAggregations(methodAggregations = [], globalAggregations = [], typeAggregations = []) {
+        let aggregations = [];
 
+        aggregations = aggregations.concat(globalAggregations);
         aggregations = aggregations.concat(typeAggregations).filter(this.uniq);
         aggregations = aggregations.concat(methodAggregations).filter(this.uniq);
 
@@ -74,12 +75,12 @@ export default class Metric {
     }
 
     /**
-     * Define aggregation frequency
+     * Build aggregation frequency
      * @param {number} methodFrequency - method aggregation frequency
      * @param {number} globalFrequency - global aggregation frequency
      * @param {number} typeFrequency - type aggregation frequency
      */
-    setAggregationFrequency(methodFrequency, globalFrequency, typeFrequency) {
+    buildAggregationFrequency(methodFrequency, globalFrequency, typeFrequency) {
         let frequency = methodFrequency || typeFrequency || globalFrequency;
 
         return this.filterAggregationFrequency(frequency);
@@ -91,9 +92,7 @@ export default class Metric {
      * @returns {Array}
      */
     filterAggregations(aggregations = []) {
-        return aggregations.filter((item) => {
-            return aggregationList.includes(item);
-        });
+        return aggregations.filter((item) => aggregationList.includes(item));
     }
 
     /**
@@ -102,12 +101,6 @@ export default class Metric {
      * @returns {*}
      */
     filterAggregationFrequency(frequency) {
-        let freq = 10;
-
-        if (aggregationFrequencyList.includes(frequency)) {
-            freq = frequency;
-        }
-
-        return freq;
+        return (aggregationFrequencyList.includes(frequency)) ? frequency : 10;
     }
 }

dist/statful.min.js

@@ -3,25 +3,23 @@ import StatfulLogger from './logger';
 export default class StatfulUtil {
     constructor(config) {
         this.config = {};
-        this.listQueues = [];
-
-        Object.keys(config).forEach((key) => {
-            this.config[key] = config[key];
-        });
+        Object.assign(this.config, config);
 
         this.logger = new StatfulLogger(this.config.debug);
+        if (this.config && this.config.flushInterval) {
+            this.registerQueue(this.config.flushInterval);
+        }
     }
 
     /**
      * Sends HTTP request to the api
-     * @param {string} endpoint - action
-     * @param {string} requestData - request data
+     * @param {object} requestData - request data
      */
-    sendRequest(endpoint, requestData) {
-        let requestArr = [this.config.apiAddress, endpoint];
-        const requestUrl = requestArr.join('/');
+    sendRequest(requestData) {
+        const requestUrl = `${this.config.apiAddress}/beacon/metrics`;
+        requestData = JSON.stringify(requestData);
 
-        this.logger.debug('Request: ' + requestUrl, requestData);
+        this.logger.debug('Request: ${requestUrl}', requestData);
 
         let xmlHttp = new XMLHttpRequest();
         xmlHttp.open('POST', requestUrl, true);
@@ -42,32 +40,29 @@ export default class StatfulUtil {
 
     /**
      * Register a new queue
-     * @param {string} queueName - queue name
-     * @param {string} endpoint - endpoint to send requests
-     * @param {int} timeInterval - interval in milliseconds, default 30000 ms
+     * @param {number} flushInterval
      */
-    registerQueue(queueName, endpoint, timeInterval) {
-        timeInterval = timeInterval || this.config.flushInterval;
-
-        if (typeof queueName === 'string' && typeof timeInterval === 'number') {
-            this.listQueues[queueName] = {
-                data: [],
-                endpoint: endpoint
-            };
+    registerQueue(flushInterval) {
+        let metricsTimer;
 
-            this.listQueues[queueName].timer = setInterval(() => {
-                let queue = this.listQueues[queueName];
+        this.metricsQueue = [];
 
-                if (queue.data.length > 0) {
+        if (typeof this.config.flushInterval === 'number' && flushInterval > 0) {
+            metricsTimer = setInterval(() => {
+                if (this.metricsQueue.length > 0) {
                     if (!this.config.dryrun) {
-                        this.sendRequest(queue.endpoint, JSON.stringify(queue.data));
+                        this.sendRequest(this.metricsQueue);
                     } else {
-                        this.logger.debug('Dryrun data', queue.endpoint, queue.data);
+                        this.logger.debug('Dryrun data', this.metricsQueue);
                     }
-                    queue.data = [];
+                    this.metricsQueue = [];
                 }
 
-            }, timeInterval);
+            }, flushInterval);
+
+            window.addEventListener('beforeunload', () => {
+                clearInterval(metricsTimer);
+            });
 
             return true;
         } else {
@@ -76,26 +71,14 @@ export default class StatfulUtil {
     }
 
     /**
-     * Unregister queue
-     * @param {string} queueName - queue name
-     */
-    unregisterQueue(queueName) {
-        if (this.listQueues[queueName]) {
-            clearInterval(this.listQueues[queueName].timer);
-            this.listQueues[queueName] = undefined;
-        }
-    }
-
-    /**
-     * Sends an Item to a specific queue
-     * @param {string} queueName - queue name
-     * @param {object} item - object to be sent
+     * Sends a metric to the queue
+     * @param {object} metric - object to be sent
      */
-    addItemToQueue(queueName, item = {}) {
-        let sampleRateNormalized = (item.sampleRate || this.config.sampleRate || 100) / 100;
+    addMetricToQueue(metric = {}) {
+        const sampleRateNormalized = (metric.sampleRate || this.config.sampleRate || 100) / 100;
 
-        if (this.listQueues[queueName] && Math.random() <= sampleRateNormalized) {
-            this.listQueues[queueName].data.push(item);
+        if (Math.random() <= sampleRateNormalized) {
+            this.metricsQueue.push(metric);
             return true;
         } else {
             this.logger.debug('Metric was discarded due to sample rate.');

dist/statful.umd.js

@@ -57,10 +57,6 @@ export default class Statful {
             apiAddress: 'https://beacon.statful.com'
         };
 
-        this.endpoints = {
-            metrics: 'beacon/metrics'
-        };
-
         // Set default properties
         if (typeof clientConfig !== 'object' || clientConfig === null) {
             clientConfig = {};
@@ -73,16 +69,7 @@ export default class Statful {
         this.logger = new StatfulLogger(this.config.debug);
 
         // Create Util
-        this.util = new StatfulUtil({
-            apiAddress: this.config.apiAddress,
-            debug: this.config.debug,
-            dryrun: this.config.dryrun,
-            flushInterval: this.config.flushInterval,
-            timeout: this.config.timeout
-        });
-
-        //Register queue to send metrics
-        this.util.registerQueue('metrics', this.endpoints.metrics, this.config.flushInterval);
+        this.util = new StatfulUtil(this.config);
     }
 
     /**
@@ -91,16 +78,14 @@ export default class Statful {
      * @returns {number}
      */
     static measureTimeUserTiming(measureName = '') {
+        const measure = window.performance.getEntriesByName(measureName).filter((entry) => entry.entryType === 'measure');
         let time;
-        let measure = window.performance.getEntriesByName(measureName).filter((entry) => {
-            return entry.entryType === 'measure';
-        });
 
         if (measure.length > 0) {
             // Always use the most recent measure if more exist
             time = measure[measure.length - 1].duration;
         } else {
-            this.logger.debug('Measure ' + measureName + ' not found');
+            this.logger.debug(`Measure ${measureName} not found`);
         }
 
         return time;
@@ -112,7 +97,7 @@ export default class Statful {
      */
     static clearMarks(marks) {
         try {
-            if (marks) {
+            if (Array.isArray(marks)) {
                 marks.forEach((mark) => {
                     if (mark) {
                         window.performance.clearMarks(mark);
@@ -143,9 +128,11 @@ export default class Statful {
      */
     static clearMeasures(measures) {
         try {
-            if (measures) {
+            if (Array.isArray(measures)) {
                 measures.forEach((measure) => {
-                    window.performance.clearMeasures(measure);
+                    if (measure) {
+                        window.performance.clearMeasures(measure);
+                    }
                 });
             } else {
                 window.performance.clearMeasures();
@@ -187,11 +174,7 @@ export default class Statful {
                     clearMeasures: false
                 };
 
-                options = options || {};
-
-                Object.keys(options).forEach((key) => {
-                    defaults[key] = options[key];
-                });
+                Object.assign(defaults, options);
 
                 // Create endMark if none is set
                 if (!defaults.endMark) {
@@ -207,7 +190,7 @@ export default class Statful {
                 if (time) {
                     // Push metrics to queue
                     let metricItem = new Metric(metricName, 'timer', time, defaults, this.config);
-                    this.util.addItemToQueue('metrics', metricItem);
+                    this.util.addMetricToQueue(metricItem);
                 } else {
                     this.logger.error('Failed to get measure time to register as timer value');
                 }
@@ -234,19 +217,14 @@ export default class Statful {
      * @param {object} options - set of option (tags, agg, aggFreq, namespace)
      */
     static timer(metricName, metricValue, options = {}) {
-        try {
-            this.logger.debug('Register Timer', metricName, metricValue, options);
-            if (metricName && metricValue >= 0) {
-                options = options || {};
-
-                // Push metrics to queue
-                let item = new Metric(metricName, 'timer', metricValue, options, this.config);
-                this.util.addItemToQueue('metrics', item);
-            } else {
-                this.logger.error('Undefined metric name or invalid value to register as a timer');
-            }
-        } catch (ex) {
-            this.logger.error(ex);
+        this.logger.debug('Register Timer', metricName, metricValue, options);
+        if (!isNaN(metricValue) && metricName) {
+            metricValue = Math.abs(metricValue);
+            // Push metrics to queue
+            let item = new Metric(metricName, 'timer', metricValue, options, this.config);
+            this.util.addMetricToQueue(item);
+        } else {
+            this.logger.error('Undefined metric name or invalid value to register as a timer');
         }
     }
 
@@ -256,43 +234,33 @@ export default class Statful {
      * @param {number} metricValue - count value to be sent
      * @param {object} options - set of option (tags, agg, aggFreq, namespace)
      */
-    static counter(metricName, metricValue, options = {}) {
-        try {
-            this.logger.debug('Register Counter', metricName, options);
-            metricValue = metricValue || 1;
-
-            if (metricName) {
-                options = options || {};
+    static counter(metricName, metricValue = 1, options = {}) {
+        this.logger.debug('Register Counter', metricName, options);
+        if (!isNaN(metricValue) && metricName) {
+            metricValue = Math.abs(parseInt(metricValue, 10));
 
-                // Push metrics to queue
-                let item = new Metric(metricName, 'counter', metricValue, options, this.config);
-                this.util.addItemToQueue('metrics', item);
-            } else {
-                this.logger.error('Undefined metric name to register as a counter');
-            }
-        } catch (ex) {
-            this.logger.error(ex);
+            // Push metrics to queue
+            let item = new Metric(metricName, 'counter', metricValue, options, this.config);
+            this.util.addMetricToQueue(item);
+        } else {
+            this.logger.error('Undefined metric name or invalid value to register as a counter');
         }
     }
 
     /**
      * Register gauge
-     * @param {string} metricName metric name to be sent
-     * @param {number} metricValue gauge value to be sent
+     * @param {string} metricName -  metric name to be sent
+     * @param {number} metricValue - gauge value to be sent
      * @param {object} options - set of option (tags, agg, aggFreq, namespace)
      */
     static gauge(metricName, metricValue, options = {}) {
-        try {
-            this.logger.debug('Register Gauge', metricName, metricValue, options);
-            if (metricName && metricValue) {
-                // Push metrics to queue
-                let item = new Metric(metricName, 'gauge', metricValue, options, this.config);
-                this.util.addItemToQueue('metrics', item);
-            } else {
-                this.logger.error('Undefined metric name/value to register as a gauge');
-            }
-        } catch (ex) {
-            this.logger.error(ex);
+        this.logger.debug('Register Gauge', metricName, metricValue, options);
+        if (!isNaN(metricValue) && metricName) {
+            // Push metrics to queue
+            let item = new Metric(metricName, 'gauge', metricValue, options, this.config);
+            this.util.addMetricToQueue(item);
+        } else {
+            this.logger.error('Undefined metric name or invalid value to register as a gauge');
         }
     }
 }