diff --git a/lib/logger.js b/lib/logger.js
index 2bcc61c..51b5b10 100644
--- a/lib/logger.js
+++ b/lib/logger.js
@@ -1,105 +1,108 @@
-"use strict";
-var levels = require('./levels')
-  , util = require('util')
-  , events = require('events')
-  , DEFAULT_CATEGORY = '[default]';
+/* eslint no-underscore-dangle:0 */
+'use strict';
 
-var logWritesEnabled = true;
+const levels = require('./levels');
+const EventEmitter = require('events');
+const DEFAULT_CATEGORY = '[default]';
+
+let logWritesEnabled = true;
 
 /**
- * Models a logging event.
- * @constructor
- * @param {String} categoryName name of category
- * @param {Log4js.Level} level level of message
- * @param {Array} data objects to log
- * @param {Log4js.Logger} logger the associated logger
- * @author Seth Chisamore
+ * @name LoggingEvent
+ * @namespace Log4js
  */
-function LoggingEvent(categoryName, level, data, logger) {
-  this.startTime = new Date();
-  this.categoryName = categoryName;
-  this.data = data;
-  this.level = level;
-  this.logger = logger;
+class LoggingEvent {
+  /**
+   * Models a logging event.
+   * @constructor
+   * @param {String} categoryName name of category
+   * @param {Log4js.Level} level level of message
+   * @param {Array} data objects to log
+   * @param {Logger} logger the associated logger
+   * @author Seth Chisamore
+   */
+  constructor(categoryName, level, data, logger) {
+    this.startTime = new Date();
+    this.categoryName = categoryName;
+    this.data = data;
+    this.level = level;
+    this.logger = logger;
+  }
 }
 
 /**
  * Logger to log messages.
- * use {@see Log4js#getLogger(String)} to get an instance.
- * @constructor
+ * use {@see Log4js.getLogger(String)} to get an instance.
+ *
+ * @name Logger
+ * @namespace Log4js
  * @param name name of category to log to
+ * @param level
+ *
  * @author Stephan Strittmatter
  */
-function Logger(name, level) {
-  this.category = name || DEFAULT_CATEGORY;
+class Logger extends EventEmitter {
+  constructor(name, level) {
+    super();
 
-  if (level) {
-    this.setLevel(level);
+    this.category = name || DEFAULT_CATEGORY;
+
+    if (level) {
+      this.setLevel(level);
+    }
+  }
+
+  setLevel(level) {
+    this.level = levels.toLevel(level, this.level || levels.TRACE);
+  }
+
+  removeLevel() {
+    delete this.level;
+  }
+
+  log(...args) {
+    const logLevel = levels.toLevel(args[0], levels.INFO);
+    if (!this.isLevelEnabled(logLevel)) {
+      return;
+    }
+    this._log(logLevel, args.slice(1));
+  }
+
+  isLevelEnabled(otherLevel) {
+    return this.level.isLessThanOrEqualTo(otherLevel);
+  }
+
+  _log(level, data) {
+    const loggingEvent = new LoggingEvent(this.category, level, data, this);
+    this.emit('log', loggingEvent);
   }
 }
-util.inherits(Logger, events.EventEmitter);
+
 Logger.DEFAULT_CATEGORY = DEFAULT_CATEGORY;
 Logger.prototype.level = levels.TRACE;
 
-Logger.prototype.setLevel = function (level) {
-  this.level = levels.toLevel(level, this.level || levels.TRACE);
-};
-
-Logger.prototype.removeLevel = function () {
-  delete this.level;
-};
-
-Logger.prototype.log = function () {
-  var logLevel = levels.toLevel(arguments[0], levels.INFO);
-  if (!this.isLevelEnabled(logLevel)) {
-    return;
-  }
-  var numArgs = arguments.length - 1;
-  var args = new Array(numArgs);
-  for (var i = 0; i < numArgs; i++) {
-    args[i] = arguments[i + 1];
-  }
-  this._log(logLevel, args);
-};
-
-Logger.prototype.isLevelEnabled = function (otherLevel) {
-  return this.level.isLessThanOrEqualTo(otherLevel);
-};
-
 ['Trace', 'Debug', 'Info', 'Warn', 'Error', 'Fatal', 'Mark'].forEach(
-  function (levelString) {
-    addLevelMethods(levelString);
-  }
+  levelString => { addLevelMethods(levelString); }
 );
 
-function addLevelMethods(level) {
-  level = levels.toLevel(level);
+function addLevelMethods(target) {
+  const level = levels.toLevel(target);
 
-  var levelStrLower = level.toString().toLowerCase();
-  var levelMethod = levelStrLower.replace(/_([a-z])/g, function (g) { return g[1].toUpperCase(); });
-  var isLevelMethod = levelMethod[0].toUpperCase() + levelMethod.slice(1);
+  const levelStrLower = level.toString().toLowerCase();
+  const levelMethod = levelStrLower.replace(/_([a-z])/g, g => g[1].toUpperCase());
+  const isLevelMethod = levelMethod[0].toUpperCase() + levelMethod.slice(1);
 
-  Logger.prototype['is' + isLevelMethod + 'Enabled'] = function () {
+  Logger.prototype[`is${isLevelMethod}Enabled`] = function () {
     return this.isLevelEnabled(level.toString());
   };
 
-  Logger.prototype[levelMethod] = function () {
+  Logger.prototype[levelMethod] = function (...args) {
     if (logWritesEnabled && this.isLevelEnabled(level)) {
-      var numArgs = arguments.length;
-      var args = new Array(numArgs);
-      for (var i = 0; i < numArgs; i++) {
-        args[i] = arguments[i];
-      }
       this._log(level, args);
     }
   };
 }
 
-Logger.prototype._log = function (level, data) {
-  var loggingEvent = new LoggingEvent(this.category, level, data, this);
-  this.emit('log', loggingEvent);
-};
-
 /**
  * Disable all log writes.
  * @returns {void}
@@ -116,8 +119,8 @@ function enableAllLogWrites() {
   logWritesEnabled = true;
 }
 
-exports.LoggingEvent = LoggingEvent;
-exports.Logger = Logger;
-exports.disableAllLogWrites = disableAllLogWrites;
-exports.enableAllLogWrites = enableAllLogWrites;
-exports.addLevelMethods = addLevelMethods;
+module.exports.LoggingEvent = LoggingEvent;
+module.exports.Logger = Logger;
+module.exports.disableAllLogWrites = disableAllLogWrites;
+module.exports.enableAllLogWrites = enableAllLogWrites;
+module.exports.addLevelMethods = addLevelMethods;