Log level configuration

Previous solution where only the logger function is configured had a
potential drawback - all log messages needed to be constructed even
when user is only interested in a certain log level. E.g. debug
messages that stringify returned values had to be created even if user
is only interested in 'info' level.

This commit addresses the problem by making the log level configurable.
Driver configuration now looks like:

```
const config = {
  logging: {
    level: 'debug',
    logger: (level, message) => console.log(level + ' ' + message)
  }
};

const driver = neo4j.driver(
 'bolt://localhost',
  neo4j.auth.basic('neo4j', 'password'),
  config
);
```

to enable logging of all currently supported log levels.

Levels have priorities like:

```
error: 0
warn:  1
info:  2
debug: 3
```

Enabling a certain level also enables logging of all levels with lower
priorities. When 'info' is enabled, logger will output 'error', 'warn',
'info' but not 'debug'. Level configuration is optional, 'info' is the
default value.

Author: lutovich

src/v1/index.js

@@ -69,11 +69,17 @@ const auth = {
 const USER_AGENT = "neo4j-javascript/" + VERSION;
 
 /**
- * Object containing predefined logger implementations. These are expected to be used as values of the driver config's <code>logger</code> property.
- * @property {function(level: string, message: string)} console the logger function that outputs timestamp, log level and message to <code>console.log()</code>
+ * Object containing predefined logging configurations. These are expected to be used as values of the driver config's <code>logging</code> property.
+ * @property {function(level: ?string): object} console the function to create a logging config that prints all messages to <code>console.log</code> with
+ * timestamp, level and message. It takes an optional <code>level</code> parameter which represents the maximum log level to be logged. Default value is 'info'.
  */
-const logger = {
-  console: (level, message) => console.log(`${global.Date.now()} ${level.toUpperCase()} ${message}`)
+const logging = {
+  console: level => {
+    return {
+      level: level,
+      logger: (level, message) => console.log(`${global.Date.now()} ${level.toUpperCase()} ${message}`)
+    };
+  }
 };
 
 /**
@@ -181,12 +187,21 @@ const logger = {
  *       // in loss of precision in the general case.
  *       disableLosslessIntegers: false,
  *
- *       // Specify the logger function for this driver. Function should take two arguments:
- *       //   1) <code>level</code> - string representing the log level. Supported levels are: 'error', 'warn', 'info' and 'debug'
- *       //   2) <code>message</code> - string representing the log message.
- *       // Function should not execute any blocking or long-running operations because it is often executed on a hot path.
- *       // No logging is done by default. See <code>neo4j.logger</code> object that contains predefined logger implementations.
- *       logger: (level, message) => console.log(level + ' ' + message),
+ *       // Specify the logging configuration for the driver. Object should have two properties <code>level</code> and <code>logger</code>.
+ *       //
+ *       // Property <code>level</code> represents the logging level which should be one of: 'error', 'warn', 'info' or 'debug'. This property is optional and
+ *       // its default value is 'info'. Levels have priorities: 'error': 0, 'warn': 1, 'info': 2, 'debug': 3. Enabling a certain level also enables all
+ *       // levels with lower priority. For example: 'error', 'warn' and 'info' will be logged when 'info' level is configured.
+ *       //
+ *       // Property <code>logger</code> represents the logging function which will be invoked for every log call with an acceptable level. The function should
+ *       // take two string arguments <code>level</code> and <code>message</code>. The function should not execute any blocking or long-running operations
+ *       // because it is often executed on a hot path.
+ *       //
+ *       // No logging is done by default. See <code>neo4j.logging</code> object that contains predefined logging implementations.
+ *       logging: {
+ *         level: 'info',
+ *         logger: (level, message) => console.log(level + ' ' + message)
+ *       },
  *     }
  *
  * @param {string} url The URL for the Neo4j database, for instance "bolt://localhost"
@@ -295,7 +310,7 @@ const forExport = {
   integer,
   Neo4jError,
   auth,
-  logger,
+  logging,
   types,
   session,
   error,
@@ -317,7 +332,7 @@ export {
   integer,
   Neo4jError,
   auth,
-  logger,
+  logging,
   types,
   session,
   error,

src/v1/internal/connector.js

@@ -145,7 +145,7 @@ class Connection {
       this._handleMessage(this._unpacker.unpack(buf));
     };
 
-    if (this._log.isEnabled()) {
+    if (this._log.isDebugEnabled()) {
       this._log.debug(`${this} created towards ${hostPort}`);
     }
 
@@ -168,7 +168,7 @@ class Connection {
    * @private
    */
   _initializeProtocol(version, buffer) {
-    if (this._log.isEnabled()) {
+    if (this._log.isDebugEnabled()) {
       this._log.debug(`${this} negotiated protocol version ${version}`);
     }
 
@@ -196,7 +196,7 @@ class Connection {
     this._isBroken = true;
     this._error = err;
 
-    if (this._log.isEnabled()) {
+    if (this._log.isErrorEnabled()) {
       this._log.error(`${this} experienced a fatal error ${JSON.stringify(err)}`);
     }
 
@@ -222,13 +222,13 @@ class Connection {
 
     switch( msg.signature ) {
       case RECORD:
-        if (this._log.isEnabled()) {
+        if (this._log.isDebugEnabled()) {
           this._log.debug(`${this} S: RECORD ${JSON.stringify(msg)}`);
         }
         this._currentObserver.onNext( payload );
         break;
       case SUCCESS:
-        if (this._log.isEnabled()) {
+        if (this._log.isDebugEnabled()) {
           this._log.debug(`${this} S: SUCCESS ${JSON.stringify(msg)}`);
         }
         try {
@@ -238,7 +238,7 @@ class Connection {
         }
         break;
       case FAILURE:
-        if (this._log.isEnabled()) {
+        if (this._log.isDebugEnabled()) {
           this._log.debug(`${this} S: FAILURE ${JSON.stringify(msg)}`);
         }
         try {
@@ -251,7 +251,7 @@ class Connection {
         }
         break;
       case IGNORED:
-        if (this._log.isEnabled()) {
+        if (this._log.isDebugEnabled()) {
           this._log.debug(`${this} S: IGNORED ${JSON.stringify(msg)}`);
         }
         try {
@@ -270,7 +270,7 @@ class Connection {
 
   /** Queue an INIT-message to be sent to the database */
   initialize( clientName, token, observer ) {
-    if (this._log.isEnabled()) {
+    if (this._log.isDebugEnabled()) {
       this._log.debug(`${this} C: INIT ${clientName} ${JSON.stringify(token)}`);
     }
     const initObserver = this._state.wrap(observer);
@@ -285,7 +285,7 @@ class Connection {
 
   /** Queue a RUN-message to be sent to the database */
   run( statement, params, observer ) {
-    if (this._log.isEnabled()) {
+    if (this._log.isDebugEnabled()) {
       this._log.debug(`${this} C: RUN ${statement} ${JSON.stringify(params)}`);
     }
     const queued = this._queueObserver(observer);
@@ -298,7 +298,7 @@ class Connection {
 
   /** Queue a PULL_ALL-message to be sent to the database */
   pullAll( observer ) {
-    if (this._log.isEnabled()) {
+    if (this._log.isDebugEnabled()) {
       this._log.debug(`${this} C: PULL_ALL`);
     }
     const queued = this._queueObserver(observer);
@@ -310,7 +310,7 @@ class Connection {
 
   /** Queue a DISCARD_ALL-message to be sent to the database */
   discardAll( observer ) {
-    if (this._log.isEnabled()) {
+    if (this._log.isDebugEnabled()) {
       this._log.debug(`${this} C: DISCARD_ALL`);
     }
     const queued = this._queueObserver(observer);
@@ -326,7 +326,7 @@ class Connection {
    * @return {Promise<void>} promise resolved when SUCCESS-message response arrives, or failed when other response messages arrives.
    */
   resetAndFlush() {
-    if (this._log.isEnabled()) {
+    if (this._log.isDebugEnabled()) {
       this._log.debug(`${this} C: RESET`);
     }
     this._ackFailureMuted = true;
@@ -365,7 +365,7 @@ class Connection {
       return;
     }
 
-    if (this._log.isEnabled()) {
+    if (this._log.isDebugEnabled()) {
       this._log.debug(`${this} C: ACK_FAILURE`);
     }
 
@@ -448,7 +448,7 @@ class Connection {
    * @param {function} cb - Function to call on close.
    */
   close(cb) {
-    if (this._log.isEnabled()) {
+    if (this._log.isDebugEnabled()) {
       this._log.debug(`${this} closing`);
     }
     this._ch.close(cb);