How to use the corvid-local-logger.error function in corvid-local-logger

const handleSocketEvent = async (
  handler,
  event,
  payload,
  callback = () => {}
) => {
  logger.info(`Socket event ${event} received`);
  try {
    const result = await handler(payload);
    callback(null, result);
    logger.info(`Socket event ${event} handled succesfully`);
    return result;
  } catch (err) {
    logger.info(`Socket event ${event} handling failed`);
    logger.error(err);
    callback({
      name: err.name,
      message: err.message,
      stack: err.stack
    });
  }
};

return editorPageCodePathToLocalCodePath(
      editorCodePath,
      existingLocalPageFilePaths
    );
  }
  if (
    isUnderPath("backend", editorCodePath) ||
    isUnderPath("public", editorCodePath)
  ) {
    return editorCodePath;
  }
  if (isUnderPath(".schemas", editorCodePath)) {
    return editorSchemaPathToLocalPath(editorCodePath);
  }

  logger.error(new Error(`Unknown editor code file path ${editorCodePath}`));
  return editorCodePath;
};

const backup = async (siteSrcPath, backupPath) => {
  logger.info(getMessage("Backup_Start_log"));
  try {
    await fs.emptyDir(backupPath);
    await fs.copy(siteSrcPath, backupPath);
    logger.info(getMessage("Backup_Complete_log"));
  } catch (e) {
    logger.info(getMessage("Backup_Fail_log"));
    logger.error(e);
    await deleteBackup(backupPath);
  }
};
const deleteBackup = async backupPath => {

return asyncCallback => async (...args) => {
    await backup(siteSrcPath, backupPath);
    try {
      const result = await asyncCallback(...args);
      await deleteBackup(backupPath);
      return result;
    } catch (error) {
      logger.info(
        `Restoring from backup because an error occured: ${error.message}`
      );
      logger.error(error);
      filesWatcher.pause();
      await restore(siteSrcPath, backupPath);
      filesWatcher.resume();
      throw error;
    }
  };
};

[clientMessages.FATAL_ERROR_MESSAGE]: message => {
            logger.error(
              getMessage("Pull_Client_Console_Fatal_Error_Message", { message })
            );
            reject(
              new Error(
                chalk.red(getMessage("Pull_Client_Console_Fatal_Error"))
              )
            );
          }
        })

ignoredEnsureFile: async relativePath => {
      logger.silly(
        getMessage("Watcher_Ignored_Ensure_Log", { path: relativePath })
      );
      const fullPathFile = fullPath(relativePath);
      if (await fs.exists(fullPathFile)) return;
      try {
        ignoreAction("write", relativePath);
        assertUnderRoot(relativePath);
        await fs.ensureFile(fullPathFile);
      } catch (err) {
        logger.info(
          `Failed ensuring file at [${relativePath}] failed - ${err.message}`
        );
        logger.error(err);
        removeFromIgnoredActions("write", relativePath);
        throw err;
      }
    },