dcp-worker 3.2.30-8 → 3.2.30-9

package/lib/worker-loggers/event-log.js

@@ -3,42 +3,65 @@
  *  @author     Eddie Roosenmaallen <eddie@kingsds.network>
  *  @date       August 2022
  *
- *  This logger module redirects logs to the Windows event-log, writing all
- *  console logs to it. 
+ *  This logger module emits events to the Windows event-log, writing all
+ *  console logs to it. Most worker events are passed through to be handled
+ *  by the console logger.
+ *
+ *  @TODO: This could likely be improved by handling worker events directly
+ *  and emitting events to the event log more deliberately than just
+ *  redirecting the base console output. ~ER20220831
  */
-'use strict';
 
-const os = require('os');
-if (os.platform() !== 'win32')
-  throw new Error(`Windows Event Log module is not supported on ${os.platform()}`);
+require('./common-types');
+const consoleLogger = require('./console');
 
 const { EventLog } = require('node-eventlog');
 
 // Copy the original global console object's properties onto a backup
 const _console = Object.assign({}, console);
 
-/**
- *  Initialize the eventlog worker logger
- *
- *  @param  {object} options          Options for logger behaviour (passed
- *    through to consoleLogger)
- */
-exports.init = function eventLog$$init(options)
-{
-  exports._processName = require('path').basename(process.mainModule.filename || process.argv0);
-  const source = options.source || exports._processName || 'dcp-worker';
-  exports._eventLog = new EventLog(source);
-  require('../startWorkerLogger').inspectOptions.colors = false;
-  exports.at = log;
-}
 
-/**
- * @param {string}    level    The node log level to log at
- * @param {[string]}  items    An array of strings to log as a single message
- */
-function log(level, ...items)
-{
-  {    
+const eventlogLogger = {
+  /**
+   *  Initialize the eventlog worker logger
+   *
+   *  @param  {Worker} worker           DCP Worker object to log
+   *  @param  {object} options          Options for logger behaviour (passed
+   *    through to consoleLogger)
+   */
+  init(worker, options) {
+    consoleLogger.init(worker, options);
+
+    this._processName = require('path').basename(process.mainModule.filename || process.argv0);
+    const source = options.source || this._processName || 'dcp-worker';
+    // _console.log(`036: creating new EventLog(${source}) client...`);
+    this._eventLog = new EventLog(source);
+
+    ['debug','error','info','log','warn'].forEach(level => {
+      console[level] = (...args) => this._log(level, ...args);
+    });
+  },
+
+  _log(level, ...items) {
+    const strBuilder = [`${this._processName}[${process.pid}]:`];
+    
+    items.forEach(i => {
+      try {
+        switch (typeof i) {
+          case 'object':
+            strBuilder.push(JSON.stringify(i));
+            break;
+          default:
+            strBuilder.push(String(i));
+        }
+      }
+      catch (e) {
+        if (e instanceof TypeError) {
+          strBuilder.push('[encoding error: ' + e.message + ']');
+        }
+      }
+    });
+    
     // Use the string log-level to look up the severity number:
     let severity = {
       error: 'error',
@@ -48,9 +71,18 @@ function log(level, ...items)
       debug: 'info',
     }[level];
 
-    return exports._eventLog.log(items.join(' '), severity).catch(error => {
+    // _console.debug(`074: about to actually log a line:`, strBuilder, severity);
+    return this._eventLog.log(strBuilder.join(' '), severity).catch(error => {
       if (error)
         _console.error('255: Unexpected error writing to event log:', error);
     });
   }
+};
+
+// necessary to keep `this` pointing at the correct thing when we call 
+for (const [prop, value] of Object.entries(consoleLogger))
+{
+  if (typeof value === 'function')
+    exports[prop] = value.bind(consoleLogger);
 }
+Object.assign(exports, eventlogLogger);

package/lib/worker-loggers/logfile.js

@@ -4,96 +4,122 @@
  *  @date       August 2022
  *
  *  This logger module maintains a log file, writing all console logs to it.
+ *  Most worker events are passed through to the console logger.
  */
-'use strict';
+
+require('./common-types');
+const consoleLogger = require('./console');
 
 // Copy the original global console object's properties onto a backup
 const _console = Object.assign({}, console);
 
-/**
- *  Initialize the logfile worker logger
- *
- *  @param  {object}  options          Options for logger behaviour
- *  @param  {string}  options.filepath Path to worker file; default: ./dcp-worker.log
- *  @param  {boolean} options.truncate If true, logfile will be cleared at worker startup
- */
-exports.init = function init(options)
-{
-  delete exports.init; // singleton   
-  options.verbose >= 3 && _console.debug('050: constructing LogfileConsole', options.logfile, options);
-  getLogFile(options);
-  require('../startWorkerLogger').inspectOptions.colors = Boolean(process.env.FORCE_COLOR);
-  
-  // on SIGHUP, close the output stream and open a new one
-  process.on('SIGHUP', () => {
-    getLogFile(options);
-  });
-  
-  exports.at = log;
-}
+const logfileLogger = {
+  /**
+   *  Initialize the logfile worker logger
+   *
+   *  @param  {Worker}  worker           DCP Worker object to log
+   *  @param  {object}  options          Options for logger behaviour
+   *  @param  {string}  options.filepath Path to worker file; default: ./dcp-worker.log
+   *  @param  {boolean} options.truncate If true, logfile will be cleared at worker startup
+   */
+  init(worker, options) {
+    consoleLogger.init(worker, options);
+    
+    this._filepath = options.filepath || './dcp-worker.log';
+    this.options = options;
+    
+    options.verbose >= 3 && console.debug('050: constructing LogfileConsole', this._filepath, options);
+    
+    this._getLogFile();
+    
+    // on SIGHUP, close the output stream and open a new one
+    process.on('SIGHUP', () => {
+      this._getLogFile(true);
+    });
 
-/**
- *  Return a handle to the WritableStream for this logger, creating one if
- *  necessary.
- *
- *  @return {fs.WriteStream}
- */
-function getLogFile(options)
-{
-  {
+    ['debug','error','info','log','warn'].forEach(level => {
+      console[level] = (...args) => this._log(level, ...args);
+    });
+  },
+
+  /**
+   *  Return a handle to the WritableStream for this logger, creating one if
+   *  necessary.
+   *
+   *  @param  {boolean} forceNew If truthy, close any existing stream and open
+   *                             a new one
+   *  @return {fs.WriteStream}
+   */
+  _getLogFile(forceNew = false) {
     const fs = require('fs');
     
-    if (getLogFile._file)
+    if (this._file)
     {
+      if (!forceNew)
+        return this._file;
+
       try
       {
-        getLogFile._file.end();
+        this._file.end();
       }
       catch (err)
       {
         console.error('061: failed to close old log file:', err);
       }
-      getLogFile._file = false;
+      this._file = false;
     }
     
-    const fileOptions = {
-      flags: options.truncate ? 'w' : 'a',  // NYI: cli --truncate 
+    const options = {
+      flags: this.options.truncate ? 'w' : 'a',  // NYI: cli --truncate 
     }
     
-    const file = getLogFile._file = fs.createWriteStream(options.logfile, fileOptions);
+    const file = this._file = fs.createWriteStream(this._filepath, options);
     
     // On error, close & recreate the log file
     file.on('error', err => {
       _console.error('082: console-patch::LogFileConsole write error:', err);
       
-      getLogFile(options);
+      this._getLogFile(true);
     });
     
     return file;
-  }
-}
-
-/** Write a log line to the output file. 
- *  
- *  current outputStream.
- *  @param {string} level Log level.
- *  @param {any} ...items Items to log.
- */
-function log(level, ...items)
-{
-  {
-    const logPrefix = [
+  },
+  
+  /** Write a log line to the output file. Items will be converted to strings as
+   *  possible and concatenated after the log-level and timestamp, then written to the
+   *  current outputStream.
+   *  @param {string} level Log level.
+   *  @param {any} ...items Items to log.
+   */
+  _log(level = 'none', ...items) {
+    const strBuilder = [
       (new Date()).toISOString(),
       level,
     ];
-
-    const logElements = logPrefix.concat(items);
-
+    
+    items.forEach(i => {
+      try {
+        switch (typeof i) {
+          case 'object':
+            strBuilder.push(JSON.stringify(i));
+          default:
+            strBuilder.push(String(i));
+        }
+      }
+      catch (e) {
+        if (e instanceof TypeError) {
+          strBuilder.push('[encoding error: ' + e.message + ']');
+        }
+      }
+    });
+    
     try {
-      getLogFile._file.write(logElements.join(' ') + '\n');
+      this._file.write(strBuilder.join(' ') + '\n');
     }
     catch (error) {
       _console.error('131: Unexpected error writing to log file:', error);
     }
-  }
-}
+  },
+};
+
+Object.assign(exports, consoleLogger, logfileLogger);

package/lib/worker-loggers/syslog.js

@@ -4,45 +4,66 @@
  *  @date       August 2022
  *
  *  This logger module emits log lines to a remote syslogd, writing all
- *  console logs to it.
+ *  console logs to it. Most worker events are passed through to be handled
+ *  by the console logger.
+ *
+ *  @TODO: This could likely be improved by handling worker events directly
+ *  and emitting events to the event log more deliberately than just
+ *  redirecting the base console output. ~ER20220831
  */
-'use strict';
 
-const os      = require('os');
-const syslog  = require('syslog-client');
-const process = require('process');
+require('./common-types');
+const consoleLogger = require('./console');
+
+const syslog = require('syslog-client');
 
 // Copy the original global console object's properties onto a backup
 const _console = Object.assign({}, console);
-var syslogClient;
-var processName;
 
-/**
- *  Initialize the syslog worker logger
- *
- *  @param  {object} cliArgs          Options for logger behaviour (passed
- *                                    through to consoleLogger)
- */
-exports.init = function syslog$$init(cliArgs)
-{
-  {
+
+const eventlogLogger = {
+  /**
+   *  Initialize the syslog worker logger
+   *
+   *  @param  {Worker} worker           DCP Worker object to log
+   *  @param  {object} options          Options for logger behaviour (passed
+   *    through to consoleLogger)
+   */
+  init(worker, options) {
+    consoleLogger.init(worker, options);
+
+    this.options = Object.assign({}, options);
     const syslogOptions = {
-      syslogHostname: os.hostname(),
-      transport: cliArgs.syslogTransport || 'udp', // tcp, udp, unix, tls
-      port:      cliArgs.syslogPort,
-      facility: syslog.Facility[cliArgs.syslogFacility[0].toUpperCase() + cliArgs.syslogFacility.slice(1)],
+      transport: options.syslogTransport || 'udp', // tcp, udp, unix, tls
+      port: options.syslogPort || 514,
     }
 
-    syslogClient = syslog.createClient(cliArgs.syslogAddress || '127.0.0.1', syslogOptions);
-    processName = require('path').basename(process.mainModule.filename || process.argv0);
-    exports.close = () => syslogClient.close();
-  }
-}
+    this._syslog = syslog.createClient(options.syslogAddress || '127.0.0.1', options);
+    this._processName = require('path').basename(process.mainModule.filename || process.argv0);
 
-function log(level, ...argv)
-{
-  {
-    const logPrefix = `${processName}[${process.pid}]: `;
+    ['debug','error','info','log','warn'].forEach(level => {
+      console[level] = (...args) => this._log(level, ...args);
+    });
+  },
+
+  _log(level, ...items) {
+    const strBuilder = [`${this._processName}[${process.pid}]:`];
+    
+    items.forEach(i => {
+      try {
+        switch (typeof i) {
+          case 'object':
+            strBuilder.push(JSON.stringify(i));
+          default:
+            strBuilder.push(String(i));
+        }
+      }
+      catch (e) {
+        if (e instanceof TypeError) {
+          strBuilder.push('[encoding error: ' + e.message + ']');
+        }
+      }
+    });
     
     // Use the string log-level to look up the severity number:
     let severity = {
@@ -53,17 +74,18 @@ function log(level, ...argv)
       debug: syslog.Severity.Debug,
     }[level];
 
-    const logMessages = argv.join(' ').split('\n');
-
-    for (let logMessage of logMessages)
-    {
-      logMessage = logPrefix + logMessage;
-      syslogClient.log(logMessage, { severity }, error => {
-        if (error)
-          _console.error('168: Unexpected error writing to syslog:');
-      });
-    }
+    this._syslog.log(strBuilder.join(' '), {
+      severity,
+    }, error => {
+      if (error)
+        _console.error('168: Unexpected error writing to syslog:', error);
+    });
   }
-}
+};
 
-exports.at = log;
+for (const [prop, value] of Object.entries(consoleLogger))
+{
+  if (typeof value === 'function')
+    exports[prop] = value.bind(consoleLogger);
+}
+Object.assign(exports, eventlogLogger);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dcp-worker",
-  "version": "3.2.30-8",
+  "version": "3.2.30-9",
   "description": "JavaScript portion of DCP Workers for Node.js",
   "main": "bin/dcp-worker",
   "keywords": [
@@ -12,7 +12,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@gitlab.com/Distributed-Compute-Protocol/dcp-worker.git"
+    "url": "git@github.com:Distributed-Compute-Labs/dcp-worker.git"
   },
   "license": "MIT",
   "author": "Kings Distributed Systems",
@@ -38,26 +38,17 @@
     "blessed-contrib": "^4.11.0",
     "chalk": "^4.1.0",
     "dcp-client": "4.3.0-4",
-    "semver": "^7.3.8",
-    "syslog-client": "1.1.1"
+    "semver": "^7.3.8"
   },
   "optionalDependencies": {
     "telnet-console": "^1.0.4"
   },
   "devDependencies": {
     "@kingsds/eslint-config": "^1.0.1",
-    "eslint": ">=8"
-  },
-  "peerDependencies": {
-    "node-eventlog": "https://gitpkg.now.sh/Distributive-Network/node-eventlog/package?dcp/0.0.1"
-  },
-  "peerDependenciesMeta": {
-    "node-eventlog": {
-      "optional": true
-    }
+    "eslint": "7.30.0"
   },
   "engines": {
-    "node": ">=18",
-    "npm": ">=7"
+    "node": ">=16",
+    "npm": ">=6"
   }
 }