dcp-worker 4.5.0 → 4.5.2

package/lib/loggers.js

@@ -183,7 +183,7 @@ exports.hook = function loggers$$hook(console, options)
    */
   globalThis.console.throb = (...args) => {
     console.throb(...args);
-    multiplex('info', ...args);
+    multiplex('throb', ...args);
   };
 }
 

package/lib/p2p-shared.js

@@ -0,0 +1,314 @@
+/**
+ * @file       lib/p2p-shared.js
+ * @author     Wes Garland, wes@distributive.network
+ * @date       June 2026
+ *
+ * Common code for working with the p2p subsystem of the event router in the dcp-worker application.
+ * The worker uses its local identity for communication and listens on #worker-${workerId} for control
+ * messages. The only authorized sender for the control channel is channel is worker.owner. When an
+ * application wants to hear from a given worker, it must add worker.identity to the list of authorized
+ * senders on the channel it is listening on.
+ */
+'use strict';
+
+const p2p    = require('dcp/p2p');
+const debug  = require('debug');
+const assert = require('assert');
+const wallet = require('dcp/wallet');
+
+const { a$sleep } = require('dcp/utils');
+const { DcpURL }  = require('dcp/dcp-url');
+
+const version = '1.0.0';
+var worker;     /* singleton instance of DistributiveWorker - held even after stop */
+var workerId;   /* worker's opaque id - persisted in case stop() resets it */
+var owner;      /* address of worker owner */
+var running;    /* 'running' | 'will-pause' | false */
+
+const KVIN = new (require('dcp/internal/kvin').KVIN)();
+KVIN.userCtors[wallet.Address.name] = wallet.Address;
+KVIN.userCtors[DcpURL.name]         = URL;
+
+exports.disabled = false;
+exports.init = async function p2pShared$init(__worker)
+{
+  if (__worker.config.unmanaged)
+    return;
+  owner = await require('./utils').getOwner(__worker);
+  if (!owner) /* unregistered worker -- no remote control */
+    return;
+
+  worker = __worker;
+  workerId = worker.id;
+  worker.on('end', () => {
+    p2p.sendMessage(`worker-${workerId}-announce`, { announce: 'stopped', version }, owner);
+    running = false;
+  });
+  worker.on('stop', () => {
+    announce('stopping');
+    running = false;
+  });
+  worker.on('start', () => {
+    running = 'running';
+  });
+  /* "make" a connection to the event router whenever possible by copying it from the worker. */
+  const __erConnectionFactory = p2p.erConnectionFactory;
+  /* Note: disabled July 2026 due to fundamental lifecycle differences between the supervisor's
+   *       protocol manager and our need to manage/log before and after the worker has stopped. /wg
+   */
+  if (false)
+    p2p.erConnectionFactory = () => worker?.getConnection('eventRouter') || __erConnectionFactory();
+
+  /* Listen for control mesages on #worker-ID, and send an unsolicited notification, 'boot', on
+   * #worker-ID-announce so that connected entities (eg portal) will notice that the worker has booted
+   * and will, for example, know to re-send commands like "log on".
+   */
+  p2p.listen([ owner ], `worker-${workerId}`, handleControlMessage);
+  p2p.on('listening', ev => {
+    announce('hello');
+  });
+}
+
+/**
+ * Start the p2p shutdown sequence. No further p2p should take place after the returned promise resolves.
+ */
+exports.shutdown = async function shutdown()
+{
+  if (workerId && owner && !exports.disabled)
+    announce('shutdown');
+  debug('dcp-worker:p2p')('cleanup for exit');
+  await p2p.cleanupForExit();
+}
+
+function announce(announcement, details)
+{
+  debug('dcp-worker:p2p')('sending anouncement', announcement);
+  if (!workerId)
+    throw new Error(`missing worker id for ${announcement} announcement`);
+  if (announcement === 'error')
+  {
+    assert(details instanceof Error);
+    const enumerableDetails = {};
+    Object.getOwnPropertyNames(details).forEach(prop => enumerableDetails[prop] = details[prop]);
+    details = enumerableDetails;
+  }
+
+  if (!exports.disabled)
+    p2p.sendMessage(`worker-${workerId}-announce`, { announce: announcement, version }, owner);
+}
+
+function enqRespond(message, details)
+{
+  assert(message.cmd === 'enq');
+  if (exports.disabled)
+    return;
+  if (!workerId)
+    throw new Error(`missing worker id for ${message.enq} enquiry response`);
+  if (message.detailsSerializer === 'kvin')
+    details = KVIN.marshal(details);
+  p2p.sendMessage(`worker-${workerId}-enq`, { enq: message.enq, detailsSerializer: message.detailsSerializer, details, version }, owner);
+}
+
+function handleEnquireMessage(message, channel, sender, originator)
+{
+  debug('dcp-worker:p2p')('sending enquiry info for', message.enq);
+  assert(message.cmd === 'enq');
+
+  switch(message.enq)
+  {
+    default:
+      console.error(`Invalid enquire message ${message.enq} from ${originator.party}:`, message);
+      break;
+    case 'runinfo':
+      enqRespond(message, worker.runInfo);
+      break;
+    case 'ping':
+      enqRespond(message, 'pong');
+      break;
+    case 'running-config':
+      enqRespond(message, makeRunningConfig(false, message.detailsSerializer !== 'kvin'));
+      break;
+    case 'explain-config':
+      enqRespond(message, { confSources: worker.confSources });
+      break;
+  }
+}
+
+/**
+ * Pause the worker. If it takes more than one second to quiesce the worker, log output is printed which estimates the time to quiescence.
+ * @returns {Promise}    a promise that resolves when the worker is quiescent
+ */
+function pauseWorker()
+{
+  let paused = false;
+  if (!running)
+  {
+    console.info(' . Will pause worker on start');
+    worker.once('start', pauseWorker);
+    running = 'will-pause';
+  }
+  if (running !== 'running')
+    return;
+
+  console.info(' . Pausing worker');
+  announce('paused');
+  const p$pause = worker.pause();
+  p$pause.then(why => {
+    if (why === 'quiescent')
+    {
+      paused = true;
+      console.info(' - Pause: worker quiescent');
+    }
+  });
+  a$sleep(paused ? 0 : 1).then(() => {
+    var remainingMs = null;
+    var duration = '';
+    const sandboxes = worker.inspect.workingSandboxes;
+    if (!worker.inspect.paused)
+      return;
+    for (let sandbox of sandboxes)
+      if (sandbox.remainingMs > remainingMs || remainingMs === null)
+        remainingMs = sandbox.remainingMs;
+    remainingMs = Number(remainingMs);
+    if (sandboxes.length)
+    {
+      duration = isNaN(remainingMs)
+        ? ', unknown duration to quiescence'
+        : ', estimated duration to quiescence: ' + (Number(remainingMs / 1000).toFixed(1) + 's');
+    }
+    console.info(` - Pause: ${sandboxes.length} sandboxes running` + duration);
+  });
+
+  return p$pause;
+}
+
+/**
+ * Handle a control message, eg from the portal.  Control messages are sent on channel worker-ID and
+ * tell the worker what to do, eg enable logs, reboot, change configuration, etc.  These are always
+ * trusted, because the p2p.listen operation restricts communication on this channel to the registered
+ * owner.
+ */
+function handleControlMessage(message, channel, sender, originator)
+{
+  if (!worker || worker.config.unmanaged || exports.disabled)
+    return;
+
+  debug('dcp-worker:p2p')(`p2p party ${sender} sent ${message.cmd} control message`, message);
+
+  switch (message.cmd)
+  {
+    default:
+      console.error(`p2p party ${sender} sent unknown command '${message.cmd}'`);
+      break;
+    case 'bonjour':
+      announce('hello');
+      break;
+    case 'refresh-state':
+      if (running === 'will-pause')
+        announce('will-pause');
+      else if (worker.inspect.paused)
+        announce('paused');
+      if (worker.inspect.stopping)
+        announce('stopping');
+      if (worker.inspect.stopped)
+        announce('stopped');
+      break;
+    case 'pause':
+      pauseWorker();
+      break;
+    case 'unpause':
+      worker.unpause();
+      announce('unpaused');
+      console.info(' . Unpausing worker');
+      break;
+    case 'stop':
+      worker.stop(message.arguments?.[0]); /* announcement comes from worker<stop> */
+      break;
+    case 'halt':
+      throw new Error(`halt (p2p ${message.sender})`);
+    case 'set-cores':
+      Object.assign(worker.config.cores, message.arguments[0]);
+      worker.dropSandboxes();
+      console.info(' . Set cores:',  worker.config.cores);
+      break;
+    case 'set-max-sandboxes':
+      worker.config.maxSandboxes = Number(message.arguments[0]);
+      console.info(' . Set max sandboxes:',  worker.config.maxSandboxes);
+      break;
+    case 'update-runinfo':
+      worker.updateRunInfo();
+      break;
+    case 'register':
+    {
+      const [ s$key, label ] = message.arguments;
+      const key = new wallet.PrivateKey(s$key);
+      console.warn(` * Re-registering worker with key '${label}' (${key})`);
+      const errorReporter = function p2p$$registrationErrorReporter(errorMessage) {
+        const error = new Error(errorMessage);
+        return error;
+      };
+      worker.config.cores.cpu = 0;
+      worker.config.cores.gpu = 0;
+      worker.dropSandboxes().then(async () => {
+        const result = await require('./utils').registerWorker(worker, key, undefined, errorReporter);
+        if (result instanceof(Error))
+        {
+          console.error(result.message);
+          announce('error', result);
+        }
+        else
+        {
+          console.log(' . Registration result:', result?.status);
+          announce('registered', result);
+        }
+      }).finally(() => worker.stop(true));
+      break;
+    }
+    case 'enq':
+      handleEnquireMessage(message, channel, sender, originator);
+      break;
+    case 'log':
+      require('./worker-loggers/p2p').handleLogControlMessage(message, channel, sender, originator);
+      break;
+  }
+}
+
+/**
+ * Make a copy of the running config.
+ * @param {boolean|undefined}    jsonCompat - when true, neuter the output so that it can be serialized with JSON
+ * @param {boolean|undefined}    sanitize   - when true, remove credentials
+ * @returns {Object}
+ */
+function makeRunningConfig(sanitize, jsonCompat)
+{
+  const schedulerUrl = new URL(dcpConfig.scheduler.location.href);
+  var config = Object.assign({}, worker.config);
+  config.allowOrigins = {};
+  delete config.__allowOriginsCurrentScheduler;
+
+  /* resolve the schedulerUrl symbols in the allow origins to a real URL */
+  for (let allowOriginListName in worker.config.allowOrigins)
+  {
+    const allowOriginList = worker.config.allowOrigins[allowOriginListName].slice();
+    config.allowOrigins[allowOriginListName] = allowOriginList;
+    for (let i=0; i < allowOriginList.length; i++)
+    {
+      if (allowOriginList[i] === worker.config.__allowOriginsCurrentScheduler)
+        allowOriginList[i] = schedulerUrl;
+    }
+  }
+
+  if (sanitize)
+  {
+    if (Array.isArray(config.computeGroups))
+      config.computeGroups = config.computeGroups.slice();
+    else
+      config.computeGroups = Object.assign({}, config.computeGroups);
+    for (let computeGroupKey in config.computeGroups)
+      config.computeGroups[computeGroupKey] = { joinKey: config.computeGroups[computeGroupKey].joinKey };
+  }
+
+  if (jsonCompat)
+    config = JSON.parse(JSON.stringify(config));
+  return config;
+}

package/lib/pidfile.js

@@ -80,8 +80,8 @@ exports.write = function pidfile$$write(filename)
     }
     catch (error)
     {
-      if (fd)
-        console.warn(`Warning: Could not remove pidfile at ${filename} (${error.code})`);
+      if (fd && error.code !== 'ENOENT')
+        console.warn(`Warning: Could not remove pidfile ${filename} (${error.code})`);
     }
   }
 }

package/lib/utils.js

@@ -171,23 +171,35 @@ function makeSyslogUrl(existingUrl, newArg)
 }
 
 /**
- * Retrieve the registered owner's address from the database
+ * Retrieve the registered owner's address from the database. It is assumed that the ownership will
+ * never change while the program is running, so the database lookup is cached for use by subsequent
+ * calls.
+ *
+ * @returns {Promise} a promise which resolves to
+ *             undefined => worker is running in unmanaged mode
+ *             false     => worker is not registered
+ *             Address   => address of the registered owner
  */
 async function getOwner(worker)
 {
   const { DistributiveWorker } = require('dcp/worker');
-  const identity = require('dcp/identity');
 
   if (worker.config.unmanaged)
     return undefined;
-  const db = await DistributiveWorker.jnuConnect();
-  const cursor = await db.select({
-    table: 'w$worker', prototype: {
-      opaqueId: worker.id,
-    }
-  });
-  const row = await cursor.getFirst();
-  return row?.owner;
+
+  if (getOwner.cache === undefined)
+  {
+    const db = await DistributiveWorker.jnuConnect();
+    const cursor = await db.select({
+      table: 'w$worker', prototype: {
+        opaqueId: worker.id,
+      }
+    });
+    const row = await cursor.getFirst();
+    getOwner.cache = row?.owner || false;
+  }
+
+  return getOwner.cache;
 }
 
 /**
@@ -197,19 +209,26 @@ async function getOwner(worker)
  * @param {string}            rkey             the registration key
  * @param {string|undefined}  label            optional value for worker.label
  * @param {function}          errorReporter    function used to report user errors; accepts string
- * @returns string if successful, instanceof Error if there was an error on the server. In either case,
- *          this is the return value from DistributiveWorker::register.
+ *
+ * @returns {any} the string 'registered' indicates a successful registration. An instance of Error is
+ *                returned when there is an error at the I/O layer; this is the raw return value of 
+ *                DistributiveWorker::register, which actually comes from submitSignedPost. In the case
+ *                when I/O is okay but the worker is not registered, and in the case where there is a
+ *                problem with the registration data itself, this function will pass a string into the
+ *                errorReporter function and return that function's return value.
  */
 async function registerWorker(worker, rkey, label, errorReporter)
 {
   const wallet = require('dcp/wallet');
   if (!wallet.isPrivateKey(rkey))
     return errorReporter('invalid registration key');
+  if (!(rkey instanceof wallet.PrivateKey))
+    rkey = new wallet.PrivateKey(rkey);
 
   if (label)
-    debug('dcp-worker:registration')('registering worker with key', rkey.slice(0,8), 'and label', label);
+    debug('dcp-worker:registration')('registering worker with key', rkey.toShortString(), 'and label', label);
   else
-    debug('dcp-worker:registration')('registering worker with key', rkey.slice(0,8));
+    debug('dcp-worker:registration')('registering worker with key', rkey.toShortString());
 
   const reg = await worker.register(rkey, label);
   if (!(reg instanceof Error))
@@ -385,6 +404,7 @@ exports.noteWorkerStart = async function noteWorkerStart(worker)
   if (worker.config?.unmanaged)
     return;
 
+  debug('dcp-worker:start')('noting worker start');
   return worker.updateRunInfo({
     lastStartTime:  new Date(),
     status:         'running',

package/lib/worker-consoles/dashboard-console.js

@@ -163,7 +163,7 @@ function createDashboard()
 function setWorker(worker)
 {
   const identity = require('dcp/identity');
-  
+
   console.log(' . Starting dashboard');
   setInterval(() => screen && screen.render(), 2000).unref(); /* ensure we didn't forget to render an important update */
   updateWorkerInfo();
@@ -321,7 +321,12 @@ exports.init = function dashboardConsole$$Init()
   const logHistory = new RingBuffer(closeLogDumpSize);
   const inspect = Symbol.for('nodejs.util.inspect.custom');
 
+  /* createDashoard adds a SIGINT event handler which intereferes with orderly shutdown, so we remove it */
+  const sigintHandlers = process.listeners('SIGINT');
   createDashboard();
+  for (let sigintHandler of process.listeners('SIGINT'))
+    if (sigintHandlers.indexOf(sigintHandler) === -1)
+      process.off('SIGINT', sigintHandler);
 
   function consoleMethodFactory(logLevel)
   {
@@ -367,7 +372,8 @@ exports.init = function dashboardConsole$$Init()
   }
 
   /**
-   * Destroy the dashboard, then dump the most recent lines back to stdout/stderr.
+   * Destroy the dashboard, dump the most recent lines back to stdout/stderr, then replace the console
+   * object's methods with methods that will write to stdio to capture shutdown error locally
    */
   console.close = function dashboardConsole$$close()
   {
@@ -382,6 +388,7 @@ exports.init = function dashboardConsole$$Init()
       const { logLevel, argv } = entry;
       stdioConsole[logLevel](...argv);
     });
+    Object.assign(console, stdioConsole);
   }
 
   console.setWorker = setWorker;

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

@@ -39,6 +39,9 @@ exports.open = function eventLog$$open(options)
  */
 exports.at = function eventLog$$at(level, ...items)
 {
+ if (level === 'throb')
+    level = 'info';
+
   // Use the string log-level to look up the severity number:
   let severity = {
     [logLevels.error]:  'error',

package/lib/worker-loggers/logfile.js

@@ -88,6 +88,8 @@ function createLogFile(options, overwrite)
 function logToFile(level, ...items)
 {
   const logPrefix = `${(new Date()).toISOString()} ${level} `;
+  if (level === 'throb')
+    level = 'info';
 
   try
   {

package/lib/worker-loggers/p2p.js

@@ -0,0 +1,197 @@
+/**
+ * @file       worker-loggers/p2p.js
+ * @author     Wes Garland, wes@distributive.network
+ * @date       June 2026
+ *
+ * This logger module emits log lines to a remote listener via the p2p subsystem of the event router.
+ * The worker uses its local identity for communication, listens on #worker-${workerId} for control
+ * messages, and sends logs on the #worker-${workerId}-log channel. The only authorized sender for
+ * the control channel is channel is worker.owner. When an application requests logs, it must add
+ * worker.identity to the list of authorized senders.
+ */
+'use strict';
+
+const os        = require('os');
+const process   = require('process');
+const debug     = require('debug');
+const p2p       = require('dcp/p2p');
+const p2pShared = require('../p2p-shared');
+
+const { RingBuffer } = require('dcp/utils');
+const logDests = new Map();  /* party => set of instances */
+var logIdSeq = 0;
+var logHistory = new RingBuffer(50);
+var disabled = true;
+
+/* Static data in log emission */
+const hostname    = os.hostname();
+const pid         = process.pid;
+const processName = require('path').basename(process.mainModule.filename);
+
+/**
+ *  Initialize the p2p worker logger.
+ *
+ *  @param  {object} options          Options for logger behaviour
+ */
+exports.open = function p2pLogs$$open(options)
+{
+  disabled = false;
+  debug('dcp-worker:logger.p2p')('initializing p2p logger subsystem');
+  p2p.on('mdr', handleMessageDeliveryReport);
+}
+
+/**
+ * Tear down the p2p logging subsystem; used by loggers::unhook(). Invoking this function makes
+ * it impossible to send any more messages to syslog, but we try to wait until all messages have been
+ * sent before resolving the close promise. This dramatically increases the probability that uncaught
+ * exceptions that crash the worker are actually logged some place other than the system console.
+ */
+exports.close = async function p2pLog$$a$close()
+{
+  debug('dcp-worker:logger.p2p')('Flushing p2p log buffers');
+  const stillMore = await p2p.flushPendingNotifications();
+  if (stillMore)
+    await p2p.flushPendingNotifications();
+  debug('dcp-worker:logger.p2p')('Flushed p2p log buffers, cleared log dests');
+  disabled = true;
+  logDests.clear();
+}
+
+/**
+ *  Emit a message via the p2p subsystem
+ *
+ *  @param  {string}    level Event level (info, debug, log, warning, error)
+ *  @param  {...any[]}  argv  Items to log
+ */
+exports.at = function loggers$$p2p$at(level, ...args)
+{
+  if (p2pShared.disabled || disabled)
+    return;
+
+  const date = new Date();
+  const logIdBase = `${Number(date)}-${hostname}-${processName}-${pid}`;
+  const logMessages = args.join(' ').split('\n');
+  for (let logMessage of logMessages)
+  {
+    if (!logMessage && level !== 'throb') /* skip blank lines */
+      continue;
+    const seq = (++logIdSeq).toString(36).padStart(3,0);
+    const logId = logIdBase + `-${seq}`; /* logId must be generated in lexical order including across processes */
+    if (logMessage || logHistory.head()?.logMessage) /* avoid storing excess throbber advances in history */
+      logHistory.push({ logId, date, level, logMessage });
+
+    for (let [ destination, instances ] of logDests)
+    {
+      debug('dcp-worker:logger.p2p.verbose')(`sending log message ${logId} to ${destination} (${instances.size} instances)`);
+      if (instances.size > 0)
+        p2p.sendMessage(instances.outputChannel, {
+          logId,
+          processName,
+          pid,
+          date,
+          hostname,
+          level,
+          logMessage,
+        }, destination, { mdr: 'fail' });
+    }
+  }
+}
+
+/**
+ * @param {object}   message     { cmd: 'log', arguments: [] }
+ *                               arguments[0]:
+ *                                 'off'     - disable log transmission
+ *                                 'on'      - enable log transmission
+ *                                 'history' - (re)transmit whatever is in the history buffer
+ *                                 'on-history' - enable log transmission and send the history buffer,
+ *                                                accepts an optional argument, lastLogId. If used, this
+ *                                                avoids emitting history <= lastLogId.
+ *                              arguments[1]: optional, name of the output channel, default is worker-ID-log
+ * @param {string}  channel     worker-ID (the command channel)
+ * @param {string}  sender      who sent the message (auth'd)
+ * @param {string}  originator  who sent the message (pre-auth, includes instance)
+ *
+ */
+exports.handleLogControlMessage = async function loggers$$p2p$handleLogControlMessage(message, channel, sender, originator)
+{
+  const mode = message.arguments?.[0];
+  if (message.cmd !== 'log')
+    return;
+  const outputChannel = `${channel}-log`;
+
+  switch(mode)
+  {
+    default:
+      console.error(`p2p party ${sender} sent unknown log mode '${mode}'`);
+      return;
+    case 'off':
+      await p2p.flushPendingNotifications();
+      if (logDests.has(sender))
+      {
+        const instances = logDests.get(sender);
+        instances.delete(originator.instance);
+        if (instances.size === 0)
+          logDests.delete(sender);
+      }
+      debug('dcp-worker:logger.p2p')(`p2p remote logging disabled for ${sender} (${originator.party} ${originator.instance})`);
+      break;
+    case 'on': case 'on-history':
+    {
+      debug('dcp-worker:logger.p2p')(`p2p remote logging enabled for ${sender} (${originator.party} ${originator.instance})`);
+      if (!logDests.has(sender))
+        logDests.set(sender, new Set());
+      const instances = logDests.get(sender);
+      instances.add(originator.instance);
+      instances.outputChannel = outputChannel; /* assumption: outputChannel same for all instances */
+      if (mode !== 'on-history')
+        break;
+    }
+    /* fallthrough */
+    case 'history':
+    {
+      /* History replays a few recent log messages, potentially from before remote logging was enabled.
+       * Log receivers are responsible for ignoring logs they have already processed. This can be
+       * accomplished by either tracking logId, or observing the order of logIds, which are guaranteed
+       * to be sortable in emission order. Note that it is possible to receive notifications out of
+       * order...
+       */
+      const lastLogId = message.arguments[1];
+      debug('dcp-worker:logger.p2p')('p2p history request, history length=', logHistory.length);
+      debug('dcp-worker:logger.p2p')('p2p history lastLogId=', lastLogId);
+      const conn = p2p.getErConnection();
+      /* Increase dcp batch size to accomodate the history and related announcements */
+      if (conn.options.maxMessagesPerBatch < (logHistory.length + 5))
+        conn.options.maxMessagesPerBatch = (logHistory.length + 5);
+      logHistory.forEach(entry => {
+        if (!lastLogId || entry.logId > lastLogId)
+        {
+          debug('dcp-worker:logger.p2p.verbose')(`sending historic log message ${entry.logId} to ${sender}`);
+          p2p.sendMessage(outputChannel, Object.assign({ processName, pid, hostname }, entry),
+                          sender, { mdr: 'fail' });
+        }
+        else
+        {
+          debug('dcp-worker:logger.p2p.verbose')(`${sender} already has historic log message ${entry.logId}`);
+        }
+      });
+    }
+  }
+}
+
+function handleMessageDeliveryReport(mdr)
+{
+  debug('dcp-worker:logger.p2p.mdr')('received MDR', mdr);
+  if (mdr.disposition !== 'fail' || mdr.details.failure !== 'nochan')
+    return;
+
+  /* nochan failure => nobody is listening for our messages */
+  for (let [ _destination, instances ] of logDests)
+  {
+    debug('dcp-worker:logger.p2p.mdr')('output channel is', instances.outputChannel);
+    if (instances.outputChannel === mdr.details.channel)
+    {
+      debug('dcp-worker:logger.p2p.mdr')('clearing instance');
+      instances.clear();
+    }
+  }
+}

package/lib/worker-loggers/syslog.js

@@ -145,6 +145,8 @@ exports.close = function a$syslog$$Close()
 function syslogAt(level, ...argv)
 {
   const logPrefix = `${processName}[${process.pid}]: `;
+  if (level === 'throb')
+    level = 'info';
 
   // Use the string log-level to look up the severity number:
   let severity = {