Update node requirements. Closes #114

hapijs · Feb 12, 2019 · dc7295d · dc7295d
1 parent b22bbf3
commit dc7295d
Show file tree

Hide file tree

Showing 8 changed files with 410 additions and 347 deletions.
diff --git a/.gitignore b/.gitignore
@@ -1,17 +1,13 @@
-.idea
-*.iml
-npm-debug.log
-dump.rdb
-node_modules
-results.tap
-results.xml
-npm-shrinkwrap.json
-config.json
-.DS_Store
-*/.DS_Store
-*/*/.DS_Store
-._*
-*/._*
-*/*/._*
+**/node_modules
+**/package-lock.json
+
 coverage.*
-lib-cov
+
+**/.DS_Store
+**/._*
+
+**/*.pem
+
+**/.vs
+**/.vscode
+**/.idea
diff --git a/.npmignore b/.npmignore
@@ -0,0 +1,4 @@
+*
+!lib/**
+!.npmignore
+!npm-shrinkwrap.json
diff --git a/.travis.yml b/.travis.yml
@@ -1,8 +1,8 @@
-sudo: false
 language: node_js
 
 node_js:
-  - "4"
-  - "6"
   - "8"
+  - "10"
   - "node"
+
+sudo: false
diff --git a/LICENSE b/LICENSE
@@ -1,4 +1,5 @@
-Copyright (c) 2012-2014, Walmart and other contributors.
+Copyright (c) 2012-2019, Project contributors
+Copyright (c) 2012-2014, Walmart
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
@@ -22,7 +23,3 @@ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-                                  *   *   *
-
-The complete list of contributors can be found at: https://github.com/hapijs/good-console/graphs/contributors
diff --git a/lib/index.js b/lib/index.js
@@ -1,12 +1,12 @@
 'use strict';
 
-// Load Modules
+const Stream = require('stream');
 
 const Hoek = require('hoek');
 const Moment = require('moment');
-const Stream = require('stream');
 const SafeStringify = require('json-stringify-safe');
 
+
 const internals = {
     defaults: {
         format: 'YYMMDD/HHmmss.SSS',
@@ -15,173 +15,178 @@ const internals = {
     }
 };
 
-internals.utility = {
-    formatOutput(event, settings) {
 
-        let timestamp = Moment(parseInt(event.timestamp, 10));
+module.exports = internals.GoodConsole = class extends Stream.Transform {
 
-        if (settings.utc) {
-            timestamp = timestamp.utc();
-        }
+    constructor(config) {
 
-        timestamp = timestamp.format(settings.format);
+        super({ objectMode: true });
 
-        event.tags = event.tags.toString();
-        const tags = ` [${event.tags}] `;
+        config = config || {};
+        this._settings = Hoek.applyToDefaults(internals.defaults, config);
+    }
 
-        // add event id information if available, typically for 'request' events
-        const id = event.id ? ` (${event.id})` : '';
+    _transform(data, enc, next) {
 
-        const output = `${timestamp},${id}${tags}${event.data}`;
+        const eventName = data.event;
+        let tags = [];
+
+        if (Array.isArray(data.tags)) {
+            tags = data.tags.concat([]);
+        }
+        else if (data.tags) {
+            tags = [data.tags];
+        }
 
-        return output + '\n';
-    },
+        tags.unshift(eventName);
 
-    formatMethod(method, settings) {
+        if (eventName === 'error' || data.error instanceof Error) {
+            return next(null, internals.formatError(data, tags, this._settings));
+        }
 
-        const methodColors = {
-            get: 32,
-            delete: 31,
-            put: 36,
-            post: 33
-        };
+        if (eventName === 'ops') {
+            return next(null, internals.formatOps(data, tags, this._settings));
+        }
 
-        let formattedMethod = method.toLowerCase();
-        if (settings.color) {
-            const color = methodColors[method.toLowerCase()] || 34;
-            formattedMethod = `\x1b[1;${color}m${formattedMethod}\x1b[0m`;
+        if (eventName === 'response') {
+            return next(null, internals.formatResponse(data, tags, this._settings));
         }
 
-        return formattedMethod;
-    },
-
-    formatStatusCode(statusCode, settings) {
-
-        let color;
-        if (statusCode && settings.color) {
-            color = 32;
-            if (statusCode >= 500) {
-                color = 31;
-            }
-            else if (statusCode >= 400) {
-                color = 33;
-            }
-            else if (statusCode >= 300) {
-                color = 36;
-            }
-
-            return `\x1b[${color}m${statusCode}\x1b[0m`;
+        if (!data.data) {
+            data.data = '(none)';
         }
 
-        return statusCode;
-    },
+        return next(null, internals.formatDefault(data, tags, this._settings));
+    }
+};
 
-    formatResponse(event, tags, settings) {
 
-        const query = event.query ? SafeStringify(event.query) : '';
-        const method = internals.utility.formatMethod(event.method, settings);
-        const statusCode = internals.utility.formatStatusCode(event.statusCode, settings) || '';
+internals.formatOutput = function (event, settings) {
 
-        // event, timestamp, id, instance, labels, method, path, query, responseTime,
-        // statusCode, pid, httpVersion, source, remoteAddress, userAgent, referer, log
-        // method, pid, error
-        const output = `${event.instance}: ${method} ${event.path} ${query} ${statusCode} (${event.responseTime}ms)`;
+    let timestamp = Moment(parseInt(event.timestamp, 10));
 
-        const response = {
-            id: event.id,
-            timestamp: event.timestamp,
-            tags,
-            data: output
-        };
+    if (settings.utc) {
+        timestamp = timestamp.utc();
+    }
 
-        return internals.utility.formatOutput(response, settings);
-    },
+    timestamp = timestamp.format(settings.format);
 
-    formatOps(event, tags, settings) {
+    event.tags = event.tags.toString();
+    const tags = ` [${event.tags}] `;
 
-        const memory = Math.round(event.proc.mem.rss / (1024 * 1024));
-        const output = `memory: ${memory}Mb, uptime (seconds): ${event.proc.uptime}, load: [${event.os.load}]`;
+    // Add event id information if available, typically for 'request' events
 
-        const ops = {
-            timestamp: event.timestamp,
-            tags,
-            data: output
-        };
+    const id = event.id ? ` (${event.id})` : '';
 
-        return internals.utility.formatOutput(ops, settings);
-    },
+    return `${timestamp},${id}${tags}${event.data}\n`;
+};
 
-    formatError(event, tags, settings) {
 
-        const output = `message: ${event.error.message}, stack: ${event.error.stack}`;
+internals.formatMethod = function (method, settings) {
 
-        const error = {
-            id: event.id,
-            timestamp: event.timestamp,
-            tags,
-            data: output
-        };
+    const methodColors = {
+        get: 32,
+        delete: 31,
+        put: 36,
+        post: 33
+    };
 
-        return internals.utility.formatOutput(error, settings);
-    },
+    let formattedMethod = method.toLowerCase();
+    if (settings.color) {
+        const color = methodColors[method.toLowerCase()] || 34;
+        formattedMethod = `\x1b[1;${color}m${formattedMethod}\x1b[0m`;
+    }
 
-    formatDefault(event, tags, settings) {
+    return formattedMethod;
+};
 
-        const data = typeof event.data === 'object' ? SafeStringify(event.data) : event.data;
-        const output = `data: ${data}`;
 
-        const defaults = {
-            timestamp: event.timestamp,
-            id: event.id,
-            tags,
-            data: output
-        };
+internals.formatStatusCode = function (statusCode, settings) {
 
-        return internals.utility.formatOutput(defaults, settings);
+    let color;
+    if (statusCode && settings.color) {
+        color = 32;
+        if (statusCode >= 500) {
+            color = 31;
+        }
+        else if (statusCode >= 400) {
+            color = 33;
+        }
+        else if (statusCode >= 300) {
+            color = 36;
+        }
+
+        return `\x1b[${color}m${statusCode}\x1b[0m`;
     }
+
+    return statusCode;
 };
 
-class GoodConsole extends Stream.Transform {
-    constructor(config) {
 
-        super({ objectMode: true });
+internals.formatResponse = function (event, tags, settings) {
 
-        config = config || {};
-        this._settings = Hoek.applyToDefaults(internals.defaults, config);
-    }
+    const query = event.query ? SafeStringify(event.query) : '';
+    const method = internals.formatMethod(event.method, settings);
+    const statusCode = internals.formatStatusCode(event.statusCode, settings) || '';
 
-    _transform(data, enc, next) {
+    // event, timestamp, id, instance, labels, method, path, query, responseTime,
+    // statusCode, pid, httpVersion, source, remoteAddress, userAgent, referer, log
+    // method, pid, error
 
-        const eventName = data.event;
-        let tags = [];
+    const output = `${event.instance}: ${method} ${event.path} ${query} ${statusCode} (${event.responseTime}ms)`;
 
-        if (Array.isArray(data.tags)) {
-            tags = data.tags.concat([]);
-        }
-        else if (data.tags) {
-            tags = [data.tags];
-        }
+    const response = {
+        id: event.id,
+        timestamp: event.timestamp,
+        tags,
+        data: output
+    };
 
-        tags.unshift(eventName);
+    return internals.formatOutput(response, settings);
+};
 
-        if (eventName === 'error' || data.error instanceof Error) {
-            return next(null, internals.utility.formatError(data, tags, this._settings));
-        }
 
-        if (eventName === 'ops') {
-            return next(null, internals.utility.formatOps(data, tags, this._settings));
-        }
+internals.formatOps = function (event, tags, settings) {
 
-        if (eventName === 'response') {
-            return next(null, internals.utility.formatResponse(data, tags, this._settings));
-        }
+    const memory = Math.round(event.proc.mem.rss / (1024 * 1024));
+    const output = `memory: ${memory}Mb, uptime (seconds): ${event.proc.uptime}, load: [${event.os.load}]`;
 
-        if (!data.data) {
-            data.data = '(none)';
-        }
+    const ops = {
+        timestamp: event.timestamp,
+        tags,
+        data: output
+    };
 
-        return next(null, internals.utility.formatDefault(data, tags, this._settings));
-    }
-}
+    return internals.formatOutput(ops, settings);
+};
+
+
+internals.formatError = function (event, tags, settings) {
 
-module.exports = GoodConsole;
+    const output = `message: ${event.error.message}, stack: ${event.error.stack}`;
+
+    const error = {
+        id: event.id,
+        timestamp: event.timestamp,
+        tags,
+        data: output
+    };
+
+    return internals.formatOutput(error, settings);
+};
+
+
+internals.formatDefault = function (event, tags, settings) {
+
+    const data = typeof event.data === 'object' ? SafeStringify(event.data) : event.data;
+    const output = `data: ${data}`;
+
+    const defaults = {
+        timestamp: event.timestamp,
+        id: event.id,
+        tags,
+        data: output
+    };
+
+    return internals.formatOutput(defaults, settings);
+};