git commit -m "make internal properties and methods truly private

Author: mertcanaltin

lib/logger.js

@@ -8,6 +8,7 @@ const {
   ObjectKeys,
   ObjectPrototypeToString,
   SafeSet,
+  Symbol,
 } = primordials;
 
 const {
@@ -53,6 +54,18 @@ const LEVELS = {
 
 const LEVEL_NAMES = ObjectKeys(LEVELS);
 
+const kLevel = Symbol('level');
+const kLevelValue = Symbol('levelValue');
+const kBindings = Symbol('bindings');
+const kFields = Symbol('fields');
+const kStream = Symbol('stream');
+const kHandleLog = Symbol('handleLog');
+const kCreateStream = Symbol('createStream');
+const kSetLogMethods = Symbol('setLogMethods');
+const kIsError = Symbol('isError');
+const kLog = Symbol('log');
+const kSerializeError = Symbol('serializeError');
+
 // Noop function for disabled log levels
 function noop() {}
 
@@ -68,8 +81,8 @@ class LogConsumer {
 
     validateOneOf(level, 'options.level', LEVEL_NAMES);
 
-    this._level = level;
-    this._levelValue = LEVELS[level];
+    this[kLevel] = level;
+    this[kLevelValue] = LEVELS[level];
   }
 
   /**
@@ -78,7 +91,7 @@ class LogConsumer {
    * @returns {boolean}
    */
   enabled(level) {
-    return LEVELS[level] >= this._levelValue;
+    return LEVELS[level] >= this[kLevelValue];
   }
 
   /**
@@ -87,7 +100,7 @@ class LogConsumer {
   attach() {
     for (const level of LEVEL_NAMES) {
       if (this.enabled(level)) {
-        channels[level].subscribe(this._handleLog.bind(this, level));
+        channels[level].subscribe(this[kHandleLog].bind(this, level));
       }
     }
   }
@@ -98,7 +111,7 @@ class LogConsumer {
    * @param {object} record
    * @private
    */
-  _handleLog(level, record) {
+  [kHandleLog](level, record) {
     this.handle(record);
   }
 
@@ -124,12 +137,12 @@ class JSONConsumer extends LogConsumer {
 
     validateObject(fields, 'options.fields');
 
-    this._stream = stream ? this._createStream(stream) :
+    this[kStream] = stream ? this[kCreateStream](stream) :
       new Utf8Stream({ fd: 1 });
-    this._fields = fields;
+    this[kFields] = fields;
   }
 
-  _createStream(stream) {
+  [kCreateStream](stream) {
     // Fast path: already a Utf8Stream
     if (stream instanceof Utf8Stream) {
       return stream;
@@ -163,35 +176,35 @@ class JSONConsumer extends LogConsumer {
       level: record.level,
       time: record.time,
       msg: record.msg,
-      ...this._fields,
+      ...this[kFields],
       ...record.bindings,
       ...record.fields,
     };
 
     const json = JSONStringify(logObj) + '\n';
-    this._stream.write(json);
+    this[kStream].write(json);
   }
 
   /**
    * Flush pending writes
    * @param {Function} callback
    */
   flush(callback) {
-    this._stream.flush(callback);
+    this[kStream].flush(callback);
   }
 
   /**
    * Flush pending writes synchronously
    */
   flushSync() {
-    this._stream.flushSync();
+    this[kStream].flushSync();
   }
 
   /**
    * Close the consumer
    */
   end() {
-    this._stream.end();
+    this[kStream].end();
   }
 }
 
@@ -214,19 +227,19 @@ class Logger {
 
     validateObject(bindings, 'options.bindings');
 
-    this._level = level;
-    this._levelValue = LEVELS[level];
-    this._bindings = bindings;
+    this[kLevel] = level;
+    this[kLevelValue] = LEVELS[level];
+    this[kBindings] = bindings;
 
-    this._setLogMethods();
+    this[kSetLogMethods]();
   }
 
   /**
    * Replace disabled log methods with noop for performance
    * @private
    */
-  _setLogMethods() {
-    const levelValue = this._levelValue;
+  [kSetLogMethods]() {
+    const levelValue = this[kLevelValue];
 
     if (levelValue > LEVELS.trace) this.trace = noop;
     if (levelValue > LEVELS.debug) this.debug = noop;
@@ -242,7 +255,7 @@ class Logger {
    * @returns {boolean}
    */
   enabled(level) {
-    return LEVELS[level] >= this._levelValue;
+    return LEVELS[level] >= this[kLevelValue];
   }
 
   /**
@@ -257,12 +270,12 @@ class Logger {
 
     const mergedBindings = ObjectAssign(
       { __proto__: null },
-      this._bindings,
+      this[kBindings],
       bindings,
     );
 
     return new Logger({
-      level: options.level || this._level,
+      level: options.level || this[kLevel],
       bindings: mergedBindings,
     });
   }
@@ -273,7 +286,7 @@ class Logger {
    * @returns {boolean}
    * @private
    */
-  _isError(value) {
+  [kIsError](value) {
     // TODO(@mertcanaltin): Use ErrorIsError from primordials when available
     // For now, use manual check until ErrorIsError is added to primordials
 
@@ -290,16 +303,16 @@ class Logger {
    * @param {string|object} msgOrObj - Message string or object with msg property
    * @param {object} [fields] - Optional fields to merge
    */
-  _log(level, levelValue, msgOrObj, fields) {
-    if (levelValue < this._levelValue) {
+  [kLog](level, levelValue, msgOrObj, fields) {
+    if (levelValue < this[kLevelValue]) {
       return;
     }
 
     if (typeof msgOrObj === 'string') {
       if (fields !== undefined) {
         validateObject(fields, 'fields');
       }
-    } else if (!this._isError(msgOrObj)) {
+    } else if (!this[kIsError](msgOrObj)) {
       validateObject(msgOrObj, 'obj');
       validateString(msgOrObj.msg, 'obj.msg');
     }
@@ -312,10 +325,10 @@ class Logger {
     let msg;
     let logFields;
 
-    if (this._isError(msgOrObj)) {
+    if (this[kIsError](msgOrObj)) {
       msg = msgOrObj.message;
       logFields = {
-        err: this._serializeError(msgOrObj),
+        err: this[kSerializeError](msgOrObj),
         ...fields,
       };
     } else if (typeof msgOrObj === 'string') {
@@ -326,20 +339,20 @@ class Logger {
       msg = extractedMsg;
       logFields = restFields;
 
-      if (logFields.err && this._isError(logFields.err)) {
-        logFields.err = this._serializeError(logFields.err);
+      if (logFields.err && this[kIsError](logFields.err)) {
+        logFields.err = this[kSerializeError](logFields.err);
       }
 
-      if (logFields.error && this._isError(logFields.error)) {
-        logFields.error = this._serializeError(logFields.error);
+      if (logFields.error && this[kIsError](logFields.error)) {
+        logFields.error = this[kSerializeError](logFields.error);
       }
     }
 
     const record = {
       level,
       msg,
       time: DateNow(),
-      bindings: this._bindings,
+      bindings: this[kBindings],
       fields: logFields,
     };
 
@@ -353,7 +366,7 @@ class Logger {
    * @returns {object} Serialized error object
    * @private
    */
-  _serializeError(err, seen = new SafeSet()) {
+  [kSerializeError](err, seen = new SafeSet()) {
     if (seen.has(err)) {
       return '[Circular]';
     }
@@ -370,8 +383,8 @@ class Logger {
     }
 
     if (err.cause !== undefined) {
-      serialized.cause = this._isError(err.cause) ?
-        this._serializeError(err.cause, seen) :
+      serialized.cause = this[kIsError](err.cause) ?
+        this[kSerializeError](err.cause, seen) :
         err.cause;
     }
 
@@ -385,27 +398,27 @@ class Logger {
   }
 
   trace(msgOrObj, fields) {
-    this._log('trace', LEVELS.trace, msgOrObj, fields);
+    this[kLog]('trace', LEVELS.trace, msgOrObj, fields);
   }
 
   debug(msgOrObj, fields) {
-    this._log('debug', LEVELS.debug, msgOrObj, fields);
+    this[kLog]('debug', LEVELS.debug, msgOrObj, fields);
   }
 
   info(msgOrObj, fields) {
-    this._log('info', LEVELS.info, msgOrObj, fields);
+    this[kLog]('info', LEVELS.info, msgOrObj, fields);
   }
 
   warn(msgOrObj, fields) {
-    this._log('warn', LEVELS.warn, msgOrObj, fields);
+    this[kLog]('warn', LEVELS.warn, msgOrObj, fields);
   }
 
   error(msgOrObj, fields) {
-    this._log('error', LEVELS.error, msgOrObj, fields);
+    this[kLog]('error', LEVELS.error, msgOrObj, fields);
   }
 
   fatal(msgOrObj, fields) {
-    this._log('fatal', LEVELS.fatal, msgOrObj, fields);
+    this[kLog]('fatal', LEVELS.fatal, msgOrObj, fields);
   }
 }