@cloudant/couchbackup 2.9.17-SNAPSHOT.3 → 2.10.0-206

package/README.md

@@ -118,6 +118,10 @@ You may also specify the name of the output file, rather than directing the back
 couchbackup --db animaldb --log animaldb.log --resume true --output animaldb.txt
 ```
 
+### Compatibility note
+
+When using `--resume` use the same version of couchbackup that started the backup.
+
 ## Restore
 
 Now that we have our backup text file, we can restore it to a new, empty, existing database using the `couchrestore`:
@@ -132,6 +136,12 @@ or specifying the database name on the command-line:
 cat animaldb.txt | couchrestore --db animaldb2
 ```
 
+### Compatibility note
+
+**Do not use an older version of couchbackup to restore a backup created with a newer version.**
+
+Newer versions of couchbackup can restore backups created by older versions within the same major version.
+
 ## Compressed backups
 
 If we want to compress the backup data before storing to disk, we can pipe the contents through `gzip`:

package/app.js

@@ -1,4 +1,4 @@
-// Copyright © 2017, 2021 IBM Corp. All rights reserved.
+// Copyright © 2017, 2024 IBM Corp. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -19,27 +19,27 @@
  * @see module:couchbackup
  */
 
-const backupFull = require('./includes/backup.js');
+const events = require('node:events');
+const fs = require('node:fs');
+const URL = require('node:url').URL;
+const backup = require('./includes/backup.js');
 const defaults = require('./includes/config.js').apiDefaults;
-const error = require('./includes/error.js');
-const request = require('./includes/request.js');
+const { convertError, BackupError, OptionError } = require('./includes/error.js');
+const { newClient } = require('./includes/request.js');
 const restoreInternal = require('./includes/restore.js');
-const backupShallow = require('./includes/shallowbackup.js');
 const debug = require('debug')('couchbackup:app');
-const events = require('events');
-const fs = require('fs');
-const URL = require('url').URL;
+const pkg = require('./package.json');
+const { RESUME_COMMENT } = require('./includes/restoreMappings.js');
 
 /**
  * Test for a positive, safe integer.
  *
- * @param {object} x - Object under test.
+ * @param {any} x - Object under test.
  */
 function isSafePositiveInteger(x) {
   // https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
   const MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || 9007199254740991;
-  // Is it a number?
-  return Object.prototype.toString.call(x) === '[object Number]' &&
+  return (typeof x === 'number' || typeof x === 'bigint') &&
     // Is it an integer?
     x % 1 === 0 &&
     // Is it positive?
@@ -49,162 +49,235 @@ function isSafePositiveInteger(x) {
 }
 
 /**
- * Validate arguments.
+ * Validate URL.
  *
- * @param {object} url - URL of database.
- * @param {object} opts - Options.
- * @param {function} cb - Callback to be called on error.
+ * @param {string} url - URL of database.
+ * @param {boolean} isIAM - A flag if IAM authentication been used.
+ * @returns Boolean true if all checks are passing.
  */
-function validateArgs(url, opts, cb) {
+async function validateURL(url, isIAM) {
   if (typeof url !== 'string') {
-    cb(new error.BackupError('InvalidOption', 'Invalid URL, must be type string'), null);
-    return;
-  }
-  if (opts && typeof opts.bufferSize !== 'undefined' && !isSafePositiveInteger(opts.bufferSize)) {
-    cb(new error.BackupError('InvalidOption', 'Invalid buffer size option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'), null);
-    return;
-  }
-  if (opts && typeof opts.iamApiKey !== 'undefined' && typeof opts.iamApiKey !== 'string') {
-    cb(new error.BackupError('InvalidOption', 'Invalid iamApiKey option, must be type string'), null);
-    return;
-  }
-  if (opts && typeof opts.log !== 'undefined' && typeof opts.log !== 'string') {
-    cb(new error.BackupError('InvalidOption', 'Invalid log option, must be type string'), null);
-    return;
-  }
-  if (opts && typeof opts.mode !== 'undefined' && ['full', 'shallow'].indexOf(opts.mode) === -1) {
-    cb(new error.BackupError('InvalidOption', 'Invalid mode option, must be either "full" or "shallow"'), null);
-    return;
-  }
-  if (opts && typeof opts.output !== 'undefined' && typeof opts.output !== 'string') {
-    cb(new error.BackupError('InvalidOption', 'Invalid output option, must be type string'), null);
-    return;
+    throw new OptionError('Invalid URL, must be type string');
   }
-  if (opts && typeof opts.parallelism !== 'undefined' && !isSafePositiveInteger(opts.parallelism)) {
-    cb(new error.BackupError('InvalidOption', 'Invalid parallelism option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'), null);
-    return;
-  }
-  if (opts && typeof opts.requestTimeout !== 'undefined' && !isSafePositiveInteger(opts.requestTimeout)) {
-    cb(new error.BackupError('InvalidOption', 'Invalid request timeout option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]'), null);
-    return;
-  }
-  if (opts && typeof opts.resume !== 'undefined' && typeof opts.resume !== 'boolean') {
-    cb(new error.BackupError('InvalidOption', 'Invalid resume option, must be type boolean'), null);
-    return;
-  }
-
   // Validate URL and ensure no auth if using key
   try {
     const urlObject = new URL(url);
     // We require a protocol, host and path (for db), fail if any is missing.
     if (urlObject.protocol !== 'https:' && urlObject.protocol !== 'http:') {
-      cb(new error.BackupError('InvalidOption', 'Invalid URL protocol.'));
-      return;
+      throw new OptionError('Invalid URL protocol.');
     }
     if (!urlObject.pathname || urlObject.pathname === '/') {
-      cb(new error.BackupError('InvalidOption', 'Invalid URL, missing path element (no database).'));
-      return;
+      throw new OptionError('Invalid URL, missing path element (no database).');
     }
-    if (opts && opts.iamApiKey && (urlObject.username || urlObject.password)) {
-      cb(new error.BackupError('InvalidOption', 'URL user information must not be supplied when using IAM API key.'));
-      return;
+    if (isIAM && (urlObject.username || urlObject.password)) {
+      throw new OptionError('URL user information must not be supplied when using IAM API key.');
     }
   } catch (err) {
-    cb(error.wrapPossibleInvalidUrlError(err));
-    return;
+    throw convertError(err);
   }
+  return true;
+}
 
+/**
+ * Validate options.
+ *
+ * @param {object} opts - Options.
+ * @returns Boolean true if all checks are passing.
+ */
+async function validateOptions(opts) {
+  // if we don't have opts then we'll be using defaults
+  if (!opts) {
+    return true;
+  }
+  const rules = [
+    { key: 'iamApiKey', type: 'string' },
+    { key: 'log', type: 'string' },
+    { key: 'output', type: 'string' },
+    { key: 'bufferSize', type: 'number' },
+    { key: 'parallelism', type: 'number' },
+    { key: 'requestTimeout', type: 'number' },
+    { key: 'mode', type: 'enum', values: ['full', 'shallow'] },
+    { key: 'resume', type: 'boolean' }
+  ];
+
+  for (const rule of rules) {
+    const val = opts[rule.key];
+    switch (rule.type) {
+      case 'string':
+        if (typeof val !== 'undefined' && typeof val !== 'string') {
+          throw new OptionError(`Invalid ${rule.key} option, must be type string`);
+        }
+        break;
+      case 'number':
+        if (typeof val !== 'undefined' && !isSafePositiveInteger(val)) {
+          const humanized = rule.key.replace(/[A-Z]/g, l => ` ${l.toLowerCase()}`);
+          throw new OptionError(`Invalid ${humanized} option, must be a positive integer in the range (0, MAX_SAFE_INTEGER]`);
+        }
+        break;
+      case 'enum':
+        if (typeof val !== 'undefined' && rule.values.indexOf(val) === -1) {
+          const humanized = rule.values
+            .map(w => `"${w}"`)
+            .reduce((acc, w, i, arr) => {
+              return acc + (i < arr.length - 1 ? ', ' : ' or ') + w;
+            });
+          throw new OptionError(`Invalid mode option, must be either ${humanized}`);
+        }
+        break;
+      case 'boolean':
+        if (typeof val !== 'undefined' && typeof val !== 'boolean') {
+          throw new OptionError(`Invalid ${rule.key} option, must be type boolean`);
+        }
+    }
+  }
+  return true;
+}
+
+/**
+ * Show warning on invalid params in shallow mode.
+ *
+ * @param {object} opts - Options.
+ */
+async function shallowModeWarnings(opts) {
+  if (!opts || opts.mode !== 'shallow') {
+    return;
+  }
   // Perform validation of invalid options for shallow mode and WARN
   // We don't error for backwards compatibility with scripts that may have been
   // written passing complete sets of options through
-  if (opts && opts.mode === 'shallow') {
-    if (opts.log || opts.resume) {
-      console.warn('WARNING: the options "log" and "resume" are invalid when using shallow mode.');
-    }
-    if (opts.parallelism) {
-      console.warn('WARNING: the option "parallelism" has no effect when using shallow mode.');
-    }
+  if (opts.log || opts.resume) {
+    console.warn('WARNING: the options "log" and "resume" are invalid when using shallow mode.');
+  }
+  if (opts.parallelism) {
+    console.warn('WARNING: the option "parallelism" has no effect when using shallow mode.');
   }
+}
 
-  if (opts && opts.resume) {
+/**
+ * Additional checks for log on resume.
+ *
+ * @param {object} opts - Options.
+ * @returns Boolean true if all checks are passing.
+ */
+
+async function validateLogOnResume(opts) {
+  const logFileExists = opts && opts.log && fs.existsSync(opts.log);
+  if (!opts || opts.mode === 'shallow') {
+    // No opts specified, defaults will be populated.
+    // In shallow mode log/resume are irrelevant and we'll have warned already.
+    return true;
+  } else if (opts.resume) {
+    // Expecting to resume
     if (!opts.log) {
       // This is the second place we check for the presence of the log option in conjunction with resume
       // It has to be here for the API case
-      cb(new error.BackupError('NoLogFileName', 'To resume a backup, a log file must be specified'), null);
-      return;
-    } else if (!fs.existsSync(opts.log)) {
-      cb(new error.BackupError('LogDoesNotExist', 'To resume a backup, the log file must exist'), null);
-      return;
+      throw new BackupError('NoLogFileName', 'To resume a backup, a log file must be specified');
+    } else if (!logFileExists) {
+      throw new BackupError('LogDoesNotExist', 'To resume a backup, the log file must exist');
+    }
+    if (opts.bufferSize) {
+      // Warn that the bufferSize is already fixed
+      console.warn('WARNING: the original backup "bufferSize" applies when resuming a backup.');
+    }
+  } else {
+    // Not resuming
+    if (logFileExists) {
+      throw new BackupError('LogFileExists', `The log file ${opts.log} exists. ` +
+      'Use the resume option if you want to resume a backup from an existing log file.');
     }
   }
   return true;
 }
 
-function addEventListener(indicator, emitter, event, f) {
-  emitter.on(event, function(...args) {
-    if (!indicator.errored) {
-      if (event === 'error') indicator.errored = true;
-      f(...args);
-    }
-  });
+/**
+ * Validate arguments.
+ *
+ * @param {string} url - URL of database.
+ * @param {object} opts - Options.
+ * @param {boolean} backup - true for backup, false for restore
+ * @returns Boolean true if all checks are passing.
+ */
+async function validateArgs(url, opts, isBackup = true) {
+  const isIAM = opts && typeof opts.iamApiKey === 'string';
+  const validations = [
+    validateURL(url, isIAM),
+    validateOptions(opts)
+  ];
+  if (isBackup) {
+    validations.push(
+      shallowModeWarnings(opts),
+      validateLogOnResume(opts)
+    );
+  }
+  return Promise.all(validations);
 }
 
-/*
-  Check the backup database exists and that the credentials used have
-  visibility. Callback with a fatal error if there is a problem with the DB.
-  @param {string} db - database object
-  @param {function(err)} callback - error is undefined if DB exists
-*/
-function proceedIfBackupDbValid(db, callback) {
-  db.service.headDatabase({ db: db.db }).then(() => callback()).catch(err => {
-    err = error.convertResponseError(err, err => parseIfDbValidResponseError(db, err));
-    callback(err);
-  });
+/**
+ * Check the backup database exists and that the credentials used have
+ * visibility. Throw a fatal error if there is a problem with the DB.
+ *
+ * @param {object} dbClient - database client object
+ * @returns Passed in database client object
+ */
+async function validateBackupDb(dbClient) {
+  try {
+    await dbClient.service.headDatabase({ db: dbClient.dbName });
+    return dbClient;
+  } catch (err) {
+    const e = parseDbResponseError(dbClient, err);
+    if (e.name === 'DatabaseNotFound') {
+      e.message = `${err.message} Ensure the backup source database exists.`;
+    }
+    // maybe convert it to HTTPError
+    throw convertError(e);
+  }
 }
 
-/*
-  Check that the restore database exists, is new and is empty. Also verify that the credentials used have
-  visibility. Callback with a fatal error if there is a problem with the DB.
-  @param {string} db - database object
-  @param {function(err)} callback - error is undefined if DB exists, new and empty
-*/
-function proceedIfRestoreDbValid(db, callback) {
-  db.service.getDatabaseInformation({ db: db.db }).then(response => {
+/**
+ * Check that the restore database exists, is new and is empty. Also verify that the credentials used have
+ * visibility. Callback with a fatal error if there is a problem with the DB.
+ *
+ * @param {object} dbClient - database client object
+ * @returns Passed in database client object
+ */
+async function validateRestoreDb(dbClient) {
+  try {
+    const response = await dbClient.service.getDatabaseInformation({ db: dbClient.dbName });
     const { doc_count: docCount, doc_del_count: deletedDocCount } = response.result;
     // The system databases can have a validation ddoc(s) injected in them on creation.
     // This sets the doc count off, so we just complitely exclude the system databases from this check.
     // The assumption here is that users restoring system databases know what they are doing.
-    if (!db.db.startsWith('_') && (docCount !== 0 || deletedDocCount !== 0)) {
-      const notEmptyDBErr = new Error(`Target database ${db.url}${db.db} is not empty.`);
-      notEmptyDBErr.name = 'DatabaseNotEmpty';
-      callback(notEmptyDBErr);
-    } else {
-      callback();
+    if (!dbClient.dbName.startsWith('_') && (docCount !== 0 || deletedDocCount !== 0)) {
+      throw new BackupError('DatabaseNotEmpty', `Target database ${dbClient.url}${dbClient.dbName} is not empty. A target database must be a new and empty database.`);
     }
-  }).catch(err => {
-    err = error.convertResponseError(err, err => parseIfDbValidResponseError(db, err));
-    callback(err);
-  });
+    // good to use
+    return dbClient;
+  } catch (err) {
+    const e = parseDbResponseError(dbClient, err);
+    if (e.name === 'DatabaseNotFound') {
+      e.message = `${e.message} Create the target database before restoring.`;
+    }
+    // maybe convert it to HTTPError
+    throw convertError(e);
+  }
 }
 
-/*
-  Convert the database validation response error to a special DatabaseNotFound error
-  in case the database is missing. Otherwise delegate to the default error factory.
-  @param {object} db - database object
-  @param {object} err - HTTP response error
-*/
-function parseIfDbValidResponseError(db, err) {
+/**
+ * Convert the database validation response error to a special DatabaseNotFound error
+ * in case the database is missing. Otherwise returns an original error.
+ * @param {object} dbClient - database client object
+ * @param {object} err - HTTP response error
+ * @returns {Error} - DatabaseNotFound error or passed in err
+ */
+function parseDbResponseError(dbClient, err) {
   if (err && err.status === 404) {
     // Override the error type and message for the DB not found case
-    const msg = `Database ${db.url}` +
-    `${db.db} does not exist. ` +
+    const msg = `Database ${dbClient.url}` +
+    `${dbClient.dbName} does not exist. ` +
     'Check the URL and database name have been specified correctly.';
-    const noDBErr = new Error(msg);
-    noDBErr.name = 'DatabaseNotFound';
-    return noDBErr;
+    return new BackupError('DatabaseNotFound', msg);
   }
-  // Delegate to the default error factory if it wasn't a 404
-  return error.convertResponseError(err);
+  return err;
 }
 
 module.exports = {
@@ -225,109 +298,52 @@ module.exports = {
    * @param {backupRestoreCallback} callback - Called on completion.
    */
   backup: function(srcUrl, targetStream, opts, callback) {
-    const listenerErrorIndicator = { errored: false };
     if (typeof callback === 'undefined' && typeof opts === 'function') {
       callback = opts;
       opts = {};
     }
-    if (!validateArgs(srcUrl, opts, callback)) {
-      // bad args, bail
-      return;
-    }
-
-    // if there is an error writing to the stream, call the completion
-    // callback with the error set
-    addEventListener(listenerErrorIndicator, targetStream, 'error', function(err) {
-      debug('Error ' + JSON.stringify(err));
-      if (callback) callback(err);
-    });
-
-    opts = Object.assign({}, defaults(), opts);
 
     const ee = new events.EventEmitter();
 
-    // Set up the DB client
-    const backupDB = request.client(srcUrl, opts);
-
-    // Validate the DB exists, before proceeding to backup
-    proceedIfBackupDbValid(backupDB, function(err) {
-      if (err) {
-        if (err.name === 'DatabaseNotFound') {
-          err.message = `${err.message} Ensure the backup source database exists.`;
-        }
-        // Didn't exist, or another fatal error, exit
-        callback(err);
-        return;
-      }
-      let backup = null;
-      if (opts.mode === 'shallow') {
-        backup = backupShallow;
-      } else { // full mode
-        backup = backupFull;
-      }
-
-      // If resuming write a newline as it's possible one would be missing from
-      // an interruption of the previous backup. If the backup was clean this
-      // will cause an empty line that will be gracefully handled by the restore.
-      if (opts.resume) {
-        targetStream.write('\n');
-      }
-
-      // Get the event emitter from the backup process so we can handle events
-      // before passing them on to the app's event emitter if needed.
-      const internalEE = backup(backupDB, opts);
-      addEventListener(listenerErrorIndicator, internalEE, 'changes', function(batch) {
-        ee.emit('changes', batch);
-      });
-      addEventListener(listenerErrorIndicator, internalEE, 'received', function(obj, q, logCompletedBatch) {
-        // this may be too verbose to have as well as the "backed up" message
-        // debug(' received batch', obj.batch, ' docs: ', obj.total, 'Time', obj.time);
-        // Callback to emit the written event when the content is flushed
-        function writeFlushed() {
-          ee.emit('written', { total: obj.total, time: obj.time, batch: obj.batch });
-          if (logCompletedBatch) {
-            logCompletedBatch(obj.batch);
-          }
-          debug(' backed up batch', obj.batch, ' docs: ', obj.total, 'Time', obj.time);
-        }
-        // Write the received content to the targetStream
-        const continueWriting = targetStream.write(JSON.stringify(obj.data) + '\n',
-          'utf8',
-          writeFlushed);
-        if (!continueWriting) {
-          // The buffer was full, pause the queue to stop the writes until we
-          // get a drain event
-          if (q && !q.paused) {
-            q.pause();
-            targetStream.once('drain', function() {
-              q.resume();
-            });
-          }
-        }
-      });
-      // For errors we expect, may or may not be fatal
-      addEventListener(listenerErrorIndicator, internalEE, 'error', function(err) {
-        debug('Error ' + JSON.stringify(err));
-        callback(err);
-      });
-      addEventListener(listenerErrorIndicator, internalEE, 'finished', function(obj) {
-        function emitFinished() {
-          debug('Backup complete - written ' + JSON.stringify(obj));
-          const summary = { total: obj.total };
-          ee.emit('finished', summary);
-          if (callback) callback(null, summary);
-        }
-        if (targetStream === process.stdout) {
-          // stdout cannot emit a finish event so use a final write + callback
-          targetStream.write('', 'utf8', emitFinished);
+    validateArgs(srcUrl, opts)
+      // Set up the DB client
+      .then(() => {
+        opts = Object.assign({}, defaults(), opts);
+        return newClient(srcUrl, opts);
+      })
+      // Validate the DB exists, before proceeding to backup
+      .then(backupDbClient => validateBackupDb(backupDbClient))
+      .then(backupDbClient => {
+        // Write either a file header or a resume marker.
+        let metadataToWrite;
+        if (opts.mode === 'full' && opts.resume) {
+          // resume is valid in full mode only
+          // Write the resume marker and a newline as it's possible one would be missing from
+          // an interruption of the previous backup. If the backup was clean this
+          // will cause an empty line that will be gracefully handled by the restore.
+          debug('Will write resume marker.');
+          metadataToWrite = `${RESUME_COMMENT}\n`;
         } else {
-          // If we're writing to a file, end the writes and register the
-          // emitFinished function for a callback when the file stream's finish
-          // event is emitted.
-          targetStream.end('', 'utf8', emitFinished);
+          // Write a file header including the name, version and mode
+          debug('Will write backup file header.');
+          metadataToWrite = `${JSON.stringify({ name: pkg.name, version: pkg.version, mode: opts.mode })}\n`;
         }
-      });
-    });
+        return new Promise((resolve, reject) => {
+          targetStream.write(metadataToWrite, 'utf-8', (err) => {
+            if (err) { reject(err); } else { resolve(backupDbClient); }
+          });
+        });
+      })
+      .then((backupDbClient) =>
+        backup(backupDbClient, opts, targetStream, ee)
+      )
+      .then((total) => {
+        debug(`Finished backup with total doc count of ${total}`);
+        ee.emit('finished', total);
+        callback(null, total);
+      })
+      .catch(e => callback(convertError(e)));
+
     return ee;
   },
 
@@ -344,64 +360,33 @@ module.exports = {
    * @param {backupRestoreCallback} callback - Called on completion.
    */
   restore: function(srcStream, targetUrl, opts, callback) {
-    const listenerErrorIndicator = { errored: false };
     if (typeof callback === 'undefined' && typeof opts === 'function') {
       callback = opts;
       opts = {};
     }
-    validateArgs(targetUrl, opts, callback);
-    opts = Object.assign({}, defaults(), opts);
 
     const ee = new events.EventEmitter();
 
-    // Set up the DB client
-    const restoreDB = request.client(targetUrl, opts);
-
-    // Validate the DB exists, before proceeding to restore
-    proceedIfRestoreDbValid(restoreDB, function(err) {
-      if (err) {
-        if (err.name === 'DatabaseNotFound') {
-          err.message = `${err.message} Create the target database before restoring.`;
-        } else if (err.name === 'DatabaseNotEmpty') {
-          err.message = `${err.message} A target database must be a new and empty database.`;
-        }
-        // Didn't exist, or another fatal error, exit
-        callback(err);
-        return;
-      }
-
-      restoreInternal(
-        restoreDB,
-        opts,
-        srcStream,
-        ee,
-        function(err, writer) {
-          if (err) {
-            callback(err, null);
-            return;
-          }
-          if (writer != null) {
-            addEventListener(listenerErrorIndicator, writer, 'restored', function(obj) {
-              debug(' restored ', obj.total);
-              ee.emit('restored', { documents: obj.documents, total: obj.total });
-            });
-            addEventListener(listenerErrorIndicator, writer, 'error', function(err) {
-              debug('Error ' + JSON.stringify(err));
-              // Only call destroy if it is available on the stream
-              if (srcStream.destroy && srcStream.destroy instanceof Function) {
-                srcStream.destroy();
-              }
-              callback(err);
-            });
-            addEventListener(listenerErrorIndicator, writer, 'finished', function(obj) {
-              debug('restore complete');
-              ee.emit('finished', { total: obj.total });
-              callback(null, obj);
-            });
-          }
-        }
-      );
-    });
+    validateArgs(targetUrl, opts, false)
+      // Set up the DB client
+      .then(() => {
+        opts = Object.assign({}, defaults(), opts);
+        return newClient(targetUrl, opts);
+      })
+      // Validate the DB exists, before proceeding to restore
+      .then((restoreDbClient) => validateRestoreDb(restoreDbClient))
+      .then((restoreDbClient) => {
+        return restoreInternal(
+          restoreDbClient,
+          opts,
+          srcStream,
+          ee);
+      })
+      .then((total) => {
+        ee.emit('finished', total);
+        callback(null, total);
+      })
+      .catch(e => callback(convertError(e)));
     return ee;
   }
 };

package/bin/couchbackup.bin.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// Copyright © 2017, 2021 IBM Corp. All rights reserved.
+// Copyright © 2017, 2024 IBM Corp. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
@@ -71,8 +71,6 @@ try {
     backupBatchDebug('Total batches received:', batch + 1);
   }).on('written', function(obj) {
     backupBatchDebug('Written batch ID:', obj.batch, 'Total document revisions written:', obj.total, 'Time:', obj.time);
-  }).on('error', function(e) {
-    backupDebug('ERROR', e);
   }).on('finished', function(obj) {
     backupDebug('Finished - Total document revisions written:', obj.total);
   });