Adding upstream version 1:115.7.0.upstream/1%115.7.0upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 971 insertions, 0 deletions

diff --git a/comm/chat/components/src/logger.sys.mjs b/comm/chat/components/src/logger.sys.mjs
new file mode 100644
index 0000000000..bde2e2945e
--- /dev/null
+++ b/comm/chat/components/src/logger.sys.mjs
@@ -0,0 +1,971 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { IMServices } from "resource:///modules/IMServices.sys.mjs";
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+import { GenericMessagePrototype } from "resource:///modules/jsProtoHelper.sys.mjs";
+import {
+  ClassInfo,
+  l10nHelper,
+} from "resource:///modules/imXPCOMUtils.sys.mjs";
+
+const lazy = {};
+ChromeUtils.defineESModuleGetters(lazy, {
+  ToLocaleFormat: "resource:///modules/ToLocaleFormat.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "_", () =>
+  l10nHelper("chrome://chat/locale/logger.properties")
+);
+
+/*
+ * Maps file paths to promises returned by ongoing IOUtils operations on them.
+ * This is so that a file can be read after a pending write operation completes
+ * and vice versa (opening a file multiple times concurrently may fail on Windows).
+ */
+export var gFilePromises = new Map();
+/**
+ * Set containing log file paths that are scheduled to have deleted messages
+ * removed.
+ *
+ * @type {Set<string>}
+ */
+export var gPendingCleanup = new Set();
+
+const kPendingLogCleanupPref = "chat.logging.cleanup.pending";
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "SHOULD_CLEANUP_LOGS",
+  "chat.logging.cleanup",
+  true
+);
+
+// Uses above map to queue operations on a file.
+export function queueFileOperation(aPath, aOperation) {
+  // Ensure the operation is queued regardless of whether the last one succeeded.
+  // This is safe since the promise is returned and consumers are expected to
+  // handle any errors. If there's no promise existing for the given path already,
+  // queue the operation on a dummy pre-resolved promise.
+  let promise = (gFilePromises.get(aPath) || Promise.resolve()).then(
+    aOperation,
+    aOperation
+  );
+  gFilePromises.set(aPath, promise);
+
+  let cleanup = () => {
+    // If no further operations have been queued, remove the reference from the map.
+    if (gFilePromises.get(aPath) === promise) {
+      gFilePromises.delete(aPath);
+    }
+  };
+  // Ensure we clear unused promises whether they resolved or rejected.
+  promise.then(cleanup, cleanup);
+
+  return promise;
+}
+
+/**
+ * Convenience method to append to a file using the above queue system. If any of
+ * the I/O operations reject, the returned promise will reject with the same reason.
+ * We open the file, append, and close it immediately. The alternative is to keep
+ * it open and append as required, but we want to make sure we don't open a file
+ * for reading while it's already open for writing, so we close it every time
+ * (opening a file multiple times concurrently may fail on Windows).
+ * Note: This function creates parent directories if required.
+ */
+export function appendToFile(aPath, aString, aCreate) {
+  return queueFileOperation(aPath, async function () {
+    await IOUtils.makeDirectory(PathUtils.parent(aPath));
+    const mode = aCreate ? "create" : "append";
+    try {
+      await IOUtils.writeUTF8(aPath, aString, {
+        mode,
+      });
+    } catch (error) {
+      // Ignore existing file when adding the header.
+      if (
+        aCreate &&
+        error.name == "NoModificationAllowedError" &&
+        error.message.startsWith("Refusing to overwrite the file")
+      ) {
+        return;
+      }
+      throw error;
+    }
+  });
+}
+
+// This function checks names against OS naming conventions and alters them
+// accordingly so that they can be used as file/folder names.
+export function encodeName(aName) {
+  // Reserved device names by Windows (prefixing "%").
+  let reservedNames = /^(CON|PRN|AUX|NUL|COM\d|LPT\d)$/i;
+  if (reservedNames.test(aName)) {
+    return "%" + aName;
+  }
+
+  // "." and " " must not be at the end of a file or folder name (appending "_").
+  if (/[\. _]/.test(aName.slice(-1))) {
+    aName += "_";
+  }
+
+  // Reserved characters are replaced by %[hex value]. encodeURIComponent() is
+  // not sufficient, nevertheless decodeURIComponent() can be used to decode.
+  function encodeReservedChars(match) {
+    return "%" + match.charCodeAt(0).toString(16);
+  }
+  return aName.replace(/[<>:"\/\\|?*&%]/g, encodeReservedChars);
+}
+
+export function getLogFolderPathForAccount(aAccount) {
+  return PathUtils.join(
+    Services.dirsvc.get("ProfD", Ci.nsIFile).path,
+    "logs",
+    aAccount.protocol.normalizedName,
+    encodeName(aAccount.normalizedName)
+  );
+}
+
+export function getLogFilePathForConversation(aConv, aStartTime) {
+  if (!aStartTime) {
+    aStartTime = aConv.startDate / 1000;
+  }
+  let path = getLogFolderPathForAccount(aConv.account);
+  let name = aConv.normalizedName;
+  if (aConv.isChat) {
+    name += ".chat";
+  }
+  return PathUtils.join(path, encodeName(name), getNewLogFileName(aStartTime));
+}
+
+export function getNewLogFileName(aStartTime) {
+  let date = aStartTime ? new Date(aStartTime) : new Date();
+  let dateTime = lazy.ToLocaleFormat("%Y-%m-%d.%H%M%S", date);
+  let offset = date.getTimezoneOffset();
+  if (offset < 0) {
+    dateTime += "+";
+    offset *= -1;
+  } else {
+    dateTime += "-";
+  }
+  let minutes = offset % 60;
+  offset = (offset - minutes) / 60;
+  function twoDigits(number) {
+    if (number == 0) {
+      return "00";
+    }
+    return number < 10 ? "0" + number : number;
+  }
+  return dateTime + twoDigits(offset) + twoDigits(minutes) + ".json";
+}
+
+/**
+ * Schedules a cleanup of the logfiles contents, removing the message texts
+ * from messages that were marked as deleted. This can be disabled by a pref.
+ *
+ * @param {string} path - Path to the logfile to clean.
+ */
+function queueLogFileCleanup(path) {
+  if (gPendingCleanup.has(path) || !lazy.SHOULD_CLEANUP_LOGS) {
+    return;
+  }
+  let idleCallback = () => {
+    if (gFilePromises.has(path)) {
+      gFilePromises.get(path).finally(() => {
+        ChromeUtils.idleDispatch(idleCallback);
+      });
+      return;
+    }
+    // Queue a new file operation to ensure nothing gets appended between
+    // reading the log and writing it back. This means we might run this when
+    // the application isn't idle, but due to the async operations that is
+    // very hard to guarantee either way.
+    queueFileOperation(path, async () => {
+      try {
+        let logContents = await IOUtils.readUTF8(path);
+        let logLines = logContents.split("\n").map(line => {
+          try {
+            return JSON.parse(line);
+          } catch {
+            return line;
+          }
+        });
+        let lastDeletionIndex = 0;
+        let deletedMessages = new Set(
+          logLines
+            .filter((message, index) => {
+              if (message.flags?.includes("deleted") && message.remoteId) {
+                lastDeletionIndex = index;
+                return true;
+              }
+              return false;
+            })
+            .map(message => message.remoteId)
+        );
+        for (let [index, message] of logLines.entries()) {
+          // If we are past the last deletion in the logs, there is no more
+          // work to be done.
+          if (index >= lastDeletionIndex) {
+            break;
+          }
+          if (
+            deletedMessages.has(message.remoteId) &&
+            !message.flags?.includes("deleted")
+          ) {
+            // Void the text of deleted messages but keep the message
+            // metadata for journaling.
+            message.text = "";
+          }
+        }
+        let cleanedLog = logLines
+          .map(line => {
+            if (typeof line === "string") {
+              return line;
+            }
+            return JSON.stringify(line);
+          })
+          .join("\n");
+        await IOUtils.writeUTF8(path, cleanedLog);
+      } catch (error) {
+        console.error(
+          "Error cleaning up log file contents for " + path + ": " + error
+        );
+      } finally {
+        gPendingCleanup.delete(path);
+        Services.prefs.setStringPref(
+          kPendingLogCleanupPref,
+          JSON.stringify(Array.from(gPendingCleanup.values()))
+        );
+      }
+    });
+  };
+  ChromeUtils.idleDispatch(idleCallback);
+  gPendingCleanup.add(path);
+  Services.prefs.setStringPref(
+    kPendingLogCleanupPref,
+    JSON.stringify(Array.from(gPendingCleanup.values()))
+  );
+}
+
+/**
+ * Schedule pending log cleanups that weren't completed last time the
+ * application was running.
+ */
+function initLogCleanup() {
+  if (!lazy.SHOULD_CLEANUP_LOGS) {
+    return;
+  }
+  // Capture the value of the pending cleanups before it gets overridden by
+  // newly scheduled cleanups.
+  let pendingCleanupPathValue = Services.prefs.getStringPref(
+    kPendingLogCleanupPref,
+    "[]"
+  );
+  // We are in no hurry to queue these cleanups, worst case we try to schedule
+  // a cleanup for a file that is already scheduled.
+  ChromeUtils.idleDispatch(() => {
+    let pendingCleanupPaths = JSON.parse(pendingCleanupPathValue) ?? [];
+    if (!Array.isArray(pendingCleanupPaths)) {
+      console.error(
+        "Pending chat log cleanup pref is not a valid array. " +
+          "Assuming all chat logs are clean."
+      );
+      return;
+    }
+    for (const path of pendingCleanupPaths) {
+      if (typeof path === "string") {
+        queueLogFileCleanup(path);
+      }
+    }
+  });
+}
+
+// One of these is maintained for every conversation being logged. It initializes
+// a log file and appends to it as required.
+function LogWriter(aConversation) {
+  this._conv = aConversation;
+  this.paths = [];
+  this.startNewFile(this._conv.startDate / 1000);
+}
+LogWriter.prototype = {
+  // All log file paths used by this LogWriter.
+  paths: [],
+  // Path of the log file that is currently being written to.
+  get currentPath() {
+    return this.paths[this.paths.length - 1];
+  },
+  // Constructor sets this to a promise that will resolve when the log header
+  // has been written.
+  _initialized: null,
+  _startTime: null,
+  _lastMessageTime: null,
+  _messageCount: 0,
+  startNewFile(aStartTime, aContinuedSession) {
+    // We start a new log file every 1000 messages. The start time of this new
+    // log file is the time of the next message. Since message times are in seconds,
+    // if we receive 1000 messages within a second after starting the new file,
+    // we will create another file, using the same start time - and so the same
+    // file name. To avoid this, ensure the new start time is at least one second
+    // greater than the current one. This is ugly, but should rarely be needed.
+    aStartTime = Math.max(aStartTime, this._startTime + 1000);
+    this._startTime = this._lastMessageTime = aStartTime;
+    this._messageCount = 0;
+    this.paths.push(getLogFilePathForConversation(this._conv, aStartTime));
+    let account = this._conv.account;
+    let header = {
+      date: new Date(this._startTime),
+      name: this._conv.name,
+      title: this._conv.title,
+      account: account.normalizedName,
+      protocol: account.protocol.normalizedName,
+      isChat: this._conv.isChat,
+      normalizedName: this._conv.normalizedName,
+    };
+    if (aContinuedSession) {
+      header.continuedSession = true;
+    }
+    header = JSON.stringify(header) + "\n";
+
+    this._initialized = appendToFile(this.currentPath, header, true);
+    // Catch the error separately so that _initialized will stay rejected if
+    // writing the header failed.
+    this._initialized.catch(aError =>
+      console.error("Failed to initialize log file:\n" + aError)
+    );
+  },
+  // We start a new log file in the following cases:
+  // - If it has been 30 minutes since the last message.
+  kInactivityLimit: 30 * 60 * 1000,
+  // - If at midnight, it's been longer than 3 hours since we started the file.
+  kDayOverlapLimit: 3 * 60 * 60 * 1000,
+  // - After every 1000 messages.
+  kMessageCountLimit: 1000,
+  async logMessage(aMessage) {
+    // aMessage.time is in seconds, we need it in milliseconds.
+    let messageTime = aMessage.time * 1000;
+    let messageMidnight = new Date(messageTime).setHours(0, 0, 0, 0);
+
+    let inactivityLimitExceeded =
+      !aMessage.delayed &&
+      messageTime - this._lastMessageTime > this.kInactivityLimit;
+    let dayOverlapLimitExceeded =
+      !aMessage.delayed &&
+      messageMidnight - this._startTime > this.kDayOverlapLimit;
+
+    if (
+      inactivityLimitExceeded ||
+      dayOverlapLimitExceeded ||
+      this._messageCount == this.kMessageCountLimit
+    ) {
+      // We start a new session if the inactivity limit was exceeded.
+      this.startNewFile(messageTime, !inactivityLimitExceeded);
+    }
+    ++this._messageCount;
+
+    if (!aMessage.delayed) {
+      this._lastMessageTime = messageTime;
+    }
+
+    let msg = {
+      date: new Date(messageTime),
+      who: aMessage.who,
+      text: aMessage.displayMessage,
+      flags: [
+        "outgoing",
+        "incoming",
+        "system",
+        "autoResponse",
+        "containsNick",
+        "error",
+        "delayed",
+        "noFormat",
+        "containsImages",
+        "notification",
+        "noLinkification",
+        "isEncrypted",
+        "action",
+        "deleted",
+      ].filter(f => aMessage[f]),
+      remoteId: aMessage.remoteId,
+    };
+    let alias = aMessage.alias;
+    if (alias && alias != msg.who) {
+      msg.alias = alias;
+    }
+    let lineToWrite = JSON.stringify(msg) + "\n";
+
+    await this._initialized;
+    try {
+      await appendToFile(this.currentPath, lineToWrite);
+    } catch (error) {
+      console.error("Failed to log message:\n" + error);
+    }
+    if (aMessage.deleted) {
+      queueLogFileCleanup(this.currentPath);
+    }
+  },
+};
+
+var dummyLogWriter = {
+  paths: null,
+  currentPath: null,
+  logMessage() {},
+};
+
+var gLogWritersById = new Map();
+export function getLogWriter(aConversation) {
+  let id = aConversation.id;
+  if (!gLogWritersById.has(id)) {
+    let prefName =
+      "purple.logging.log_" + (aConversation.isChat ? "chats" : "ims");
+    if (Services.prefs.getBoolPref(prefName)) {
+      gLogWritersById.set(id, new LogWriter(aConversation));
+    } else {
+      gLogWritersById.set(id, dummyLogWriter);
+    }
+  }
+  return gLogWritersById.get(id);
+}
+
+export function closeLogWriter(aConversation) {
+  gLogWritersById.delete(aConversation.id);
+}
+
+/**
+ * Takes a properly formatted log file name and extracts the date information
+ * and filetype, returning the results as an Array.
+ *
+ * Filenames are expected to be formatted as:
+ *
+ * YYYY-MM-DD.HHmmSS+ZZzz.format
+ *
+ * @param aFilename the name of the file
+ * @returns an Array, where the first element is a Date object for the date
+ *          that the log file represents, and the file type as a string.
+ */
+function getDateFromFilename(aFilename) {
+  const kRegExp =
+    /([\d]{4})-([\d]{2})-([\d]{2}).([\d]{2})([\d]{2})([\d]{2})([+-])([\d]{2})([\d]{2}).*\.([A-Za-z]+)$/;
+
+  let r = aFilename.match(kRegExp);
+  if (!r) {
+    console.error(
+      "Found log file with name not matching YYYY-MM-DD.HHmmSS+ZZzz.format: " +
+        aFilename
+    );
+    return [];
+  }
+
+  // We ignore the timezone offset for now (FIXME)
+  return [new Date(r[1], r[2] - 1, r[3], r[4], r[5], r[6]), r[10]];
+}
+
+function LogMessage(aData, aConversation) {
+  this._init(aData.who, aData.text, {}, aConversation);
+  // Not overriding time using the init options, since init also sets the
+  // property.
+  this.time = Math.round(new Date(aData.date) / 1000);
+  if ("alias" in aData) {
+    this._alias = aData.alias;
+  }
+  this.remoteId = aData.remoteId;
+  if (aData.flags) {
+    for (let flag of aData.flags) {
+      this[flag] = true;
+    }
+  }
+}
+
+LogMessage.prototype = {
+  __proto__: GenericMessagePrototype,
+  _interfaces: [Ci.imIMessage, Ci.prplIMessage],
+  get displayMessage() {
+    return this.originalMessage;
+  },
+};
+
+function LogConversation(aMessages, aProperties) {
+  this._messages = aMessages;
+  for (let property in aProperties) {
+    this[property] = aProperties[property];
+  }
+}
+LogConversation.prototype = {
+  __proto__: ClassInfo("imILogConversation", "Log conversation object"),
+  get isChat() {
+    return this._isChat;
+  },
+  get buddy() {
+    return null;
+  },
+  get account() {
+    return {
+      alias: "",
+      name: this._accountName,
+      normalizedName: this._accountName,
+      protocol: { name: this._protocolName },
+      statusInfo: IMServices.core.globalUserStatus,
+    };
+  },
+  getMessages() {
+    // Start with the newest message to filter out older versions of the same
+    // message. Also filter out deleted messages.
+    return this._messages.map(m => new LogMessage(m, this));
+  },
+};
+
+/**
+ * A Log object represents one or more log files. The constructor expects one
+ * argument, which is either a single path to a json log file or an array of
+ * objects each having two properties:
+ *   path: The full path of the (json only) log file it represents.
+ *   time: The Date object extracted from the filename of the logfile.
+ *
+ * The returned Log object's time property will be:
+ *   For a single file - exact time extracted from the name of the log file.
+ *   For a set of files - the time extracted, reduced to the day.
+ */
+function Log(aEntries) {
+  if (typeof aEntries == "string") {
+    // Assume that aEntries is a single path.
+    let path = aEntries;
+    this.path = path;
+    let [date, format] = getDateFromFilename(PathUtils.filename(path));
+    if (!date || !format) {
+      this.time = 0;
+      return;
+    }
+    this.time = date.valueOf() / 1000;
+    // Wrap the path in an array
+    this._entryPaths = [path];
+    return;
+  }
+
+  if (!aEntries.length) {
+    throw new Error(
+      "Log was passed an invalid argument, " +
+        "expected a non-empty array or a string."
+    );
+  }
+
+  // Assume aEntries is an array of objects.
+  // Sort our list of entries for this day in increasing order.
+  aEntries.sort((aLeft, aRight) => aLeft.time - aRight.time);
+
+  this._entryPaths = aEntries.map(entry => entry.path);
+  // Calculate the timestamp for the first entry down to the day.
+  let timestamp = new Date(aEntries[0].time);
+  timestamp.setHours(0);
+  timestamp.setMinutes(0);
+  timestamp.setSeconds(0);
+  this.time = timestamp.valueOf() / 1000;
+  // Path is used to uniquely identify a Log, and sometimes used to
+  // quickly determine which directory a log file is from.  We'll use
+  // the first file's path.
+  this.path = aEntries[0].path;
+}
+Log.prototype = {
+  __proto__: ClassInfo("imILog", "Log object"),
+  _entryPaths: null,
+  async getConversation() {
+    /*
+     * Read the set of log files asynchronously and return a promise that
+     * resolves to a LogConversation instance. Even if a file contains some
+     * junk (invalid JSON), messages that are valid will be read. If the first
+     * line of metadata is corrupt however, the data isn't useful and the
+     * promise will resolve to null.
+     */
+    let messages = [];
+    let properties = {};
+    let firstFile = true;
+    let decoder = new TextDecoder();
+    let lastRemoteIdIndex = {};
+    for (let path of this._entryPaths) {
+      let lines;
+      try {
+        let contents = await queueFileOperation(path, () => IOUtils.read(path));
+        lines = decoder.decode(contents).split("\n");
+      } catch (aError) {
+        console.error('Error reading log file "' + path + '":\n' + aError);
+        continue;
+      }
+      let nextLine = lines.shift();
+      let filename = PathUtils.filename(path);
+
+      let data;
+      try {
+        // This will fail if either nextLine is undefined, or not valid JSON.
+        data = JSON.parse(nextLine);
+      } catch (aError) {
+        messages.push({
+          who: "sessionstart",
+          date: getDateFromFilename(filename)[0],
+          text: lazy._("badLogfile", filename),
+          flags: ["noLog", "notification", "error", "system"],
+        });
+        continue;
+      }
+
+      if (firstFile || !data.continuedSession) {
+        messages.push({
+          who: "sessionstart",
+          date: getDateFromFilename(filename)[0],
+          text: "",
+          flags: ["noLog", "notification"],
+        });
+      }
+
+      if (firstFile) {
+        properties.startDate = new Date(data.date) * 1000;
+        properties.name = data.name;
+        properties.title = data.title;
+        properties._accountName = data.account;
+        properties._protocolName = data.protocol;
+        properties._isChat = data.isChat;
+        properties.normalizedName = data.normalizedName;
+        firstFile = false;
+      }
+
+      while (lines.length) {
+        nextLine = lines.shift();
+        if (!nextLine) {
+          break;
+        }
+        try {
+          let message = JSON.parse(nextLine);
+
+          // Backwards compatibility for old action messages.
+          if (
+            !message.flags.includes("action") &&
+            message.text?.startsWith("/me ")
+          ) {
+            message.flags.push("action");
+            message.text = message.text.slice(4);
+          }
+
+          if (message.remoteId) {
+            lastRemoteIdIndex[message.remoteId] = messages.length;
+          }
+          messages.push(message);
+        } catch (e) {
+          // If a message line contains junk, just ignore the error and
+          // continue reading the conversation.
+        }
+      }
+    }
+
+    if (firstFile) {
+      // All selected log files are invalid.
+      return null;
+    }
+
+    // Ignore older versions of edited messages and deleted messages.
+    messages = messages.filter((message, index) => {
+      if (
+        message.remoteId &&
+        lastRemoteIdIndex.hasOwnProperty(message.remoteId) &&
+        index < lastRemoteIdIndex[message.remoteId]
+      ) {
+        return false;
+      }
+      return !message.flags.includes("deleted");
+    });
+
+    return new LogConversation(messages, properties);
+  },
+};
+
+/**
+ * logsGroupedByDay() organizes log entries by date.
+ *
+ * @param {string[]} aEntries - paths of log files to be parsed.
+ * @returns {imILog[]} Logs, ordered by day.
+ */
+function logsGroupedByDay(aEntries) {
+  if (!Array.isArray(aEntries)) {
+    return [];
+  }
+
+  let entries = {};
+  for (let path of aEntries) {
+    let [logDate, logFormat] = getDateFromFilename(PathUtils.filename(path));
+    if (!logDate) {
+      // We'll skip this one, since it's got a busted filename.
+      continue;
+    }
+
+    let dateForID = new Date(logDate);
+    let dayID;
+    // If the file isn't a JSON file, ignore it.
+    if (logFormat != "json") {
+      continue;
+    }
+    // We want to cluster all of the logs that occur on the same day
+    // into the same Arrays. We clone the date for the log, reset it to
+    // the 0th hour/minute/second, and use that to construct an ID for the
+    // Array we'll put the log in.
+    dateForID.setHours(0);
+    dateForID.setMinutes(0);
+    dateForID.setSeconds(0);
+    dayID = dateForID.toISOString();
+
+    if (!(dayID in entries)) {
+      entries[dayID] = [];
+    }
+
+    entries[dayID].push({
+      path,
+      time: logDate,
+    });
+  }
+
+  let days = Object.keys(entries);
+  days.sort();
+  return days.map(dayID => new Log(entries[dayID]));
+}
+
+export function Logger() {
+  IOUtils.profileBeforeChange.addBlocker(
+    "Chat logger: writing all pending messages",
+    async function () {
+      for (let promise of gFilePromises.values()) {
+        try {
+          await promise;
+        } catch (aError) {
+          // Ignore the error, whatever queued the operation will take care of it.
+        }
+      }
+    }
+  );
+
+  Services.obs.addObserver(this, "new-text");
+  Services.obs.addObserver(this, "conversation-closed");
+  Services.obs.addObserver(this, "conversation-left-chat");
+  initLogCleanup();
+}
+
+Logger.prototype = {
+  // Returned Promise resolves to an array of entries for the
+  // log folder if it exists, otherwise null.
+  async _getLogEntries(aAccount, aNormalizedName) {
+    let path;
+    try {
+      path = PathUtils.join(
+        getLogFolderPathForAccount(aAccount),
+        encodeName(aNormalizedName)
+      );
+      if (await queueFileOperation(path, () => IOUtils.exists(path))) {
+        return await IOUtils.getChildren(path);
+      }
+    } catch (aError) {
+      console.error(
+        'Error getting directory entries for "' + path + '":\n' + aError
+      );
+    }
+    return [];
+  },
+  async getLogFromFile(aFilePath, aGroupByDay) {
+    if (!aGroupByDay) {
+      return new Log(aFilePath);
+    }
+    let [targetDate] = getDateFromFilename(PathUtils.filename(aFilePath));
+    if (!targetDate) {
+      return null;
+    }
+
+    targetDate = targetDate.toDateString();
+
+    // We'll assume that the files relevant to our interests are
+    // in the same folder as the one provided.
+    let relevantEntries = [];
+    for (const path of await IOUtils.getChildren(PathUtils.parent(aFilePath))) {
+      const stat = await IOUtils.stat(path);
+      if (stat.type === "directory") {
+        continue;
+      }
+      let [logTime] = getDateFromFilename(PathUtils.filename(path));
+      // If someone placed a 'foreign' file into the logs directory,
+      // pattern matching fails and getDateFromFilename() returns [].
+      if (logTime && targetDate == logTime.toDateString()) {
+        relevantEntries.push({
+          path,
+          time: logTime,
+        });
+      }
+    }
+    return new Log(relevantEntries);
+  },
+
+  async getLogPathsForConversation(aConversation) {
+    let writer = gLogWritersById.get(aConversation.id);
+    // Resolve to null if we haven't created a LogWriter yet for this conv, or
+    // if logging is disabled (paths will be null).
+    if (!writer || !writer.paths) {
+      return null;
+    }
+    let paths = writer.paths;
+    // Wait for any pending file operations to finish, then resolve to the paths
+    // regardless of whether these operations succeeded.
+    for (let path of paths) {
+      await gFilePromises.get(path);
+    }
+    return paths;
+  },
+  async getLogsForContact(aContact) {
+    let entries = [];
+    for (let buddy of aContact.getBuddies()) {
+      for (let accountBuddy of buddy.getAccountBuddies()) {
+        entries = entries.concat(
+          await this._getLogEntries(
+            accountBuddy.account,
+            accountBuddy.normalizedName
+          )
+        );
+      }
+    }
+    return logsGroupedByDay(entries);
+  },
+  getLogsForConversation(aConversation) {
+    let name = aConversation.normalizedName;
+    if (aConversation.isChat) {
+      name += ".chat";
+    }
+
+    return this._getLogEntries(aConversation.account, name).then(entries =>
+      logsGroupedByDay(entries)
+    );
+  },
+  async getSimilarLogs(log) {
+    let entries;
+    try {
+      entries = await IOUtils.getChildren(PathUtils.parent(log.path));
+    } catch (aError) {
+      console.error(
+        'Error getting similar logs for "' + log.path + '":\n' + aError
+      );
+    }
+    // If there was an error, this will return an empty array.
+    return logsGroupedByDay(entries);
+  },
+
+  getLogFolderPathForAccount(aAccount) {
+    return getLogFolderPathForAccount(aAccount);
+  },
+
+  deleteLogFolderForAccount(aAccount) {
+    if (!aAccount.disconnecting && !aAccount.disconnected) {
+      throw new Error(
+        "Account must be disconnected first before deleting logs."
+      );
+    }
+
+    if (aAccount.disconnecting) {
+      console.error(
+        "Account is still disconnecting while we attempt to remove logs."
+      );
+    }
+
+    let logPath = this.getLogFolderPathForAccount(aAccount);
+    // Find all operations on files inside the log folder.
+    let pendingPromises = [];
+    function checkLogFiles(promiseOperation, filePath) {
+      if (filePath.startsWith(logPath)) {
+        pendingPromises.push(promiseOperation);
+      }
+    }
+    gFilePromises.forEach(checkLogFiles);
+    // After all operations finish, remove the whole log folder.
+    return Promise.all(pendingPromises)
+      .then(values => {
+        IOUtils.remove(logPath, { recursive: true });
+      })
+      .catch(aError =>
+        console.error("Failed to remove log folders:\n" + aError)
+      );
+  },
+
+  async forEach(aCallback) {
+    let getAllSubdirs = async function (aPaths, aErrorMsg) {
+      let entries = [];
+      for (let path of aPaths) {
+        try {
+          entries = entries.concat(await IOUtils.getChildren(path));
+        } catch (aError) {
+          if (aErrorMsg) {
+            console.error(aErrorMsg + "\n" + aError);
+          }
+        }
+      }
+      let filteredPaths = [];
+      for (let path of entries) {
+        const stat = await IOUtils.stat(path);
+        if (stat.type === "directory") {
+          filteredPaths.push(path);
+        }
+      }
+      return filteredPaths;
+    };
+
+    let logsPath = PathUtils.join(
+      Services.dirsvc.get("ProfD", Ci.nsIFile).path,
+      "logs"
+    );
+    let prpls = await getAllSubdirs([logsPath]);
+    let accounts = await getAllSubdirs(
+      prpls,
+      "Error while sweeping prpl folder:"
+    );
+    let logFolders = await getAllSubdirs(
+      accounts,
+      "Error while sweeping account folder:"
+    );
+    for (let folder of logFolders) {
+      try {
+        for (const path of await IOUtils.getChildren(folder)) {
+          const stat = await IOUtils.stat(path);
+          if (stat.type === "directory" || !path.endsWith(".json")) {
+            continue;
+          }
+          await aCallback.processLog(path);
+        }
+      } catch (aError) {
+        // If the callback threw, reject the promise and let the caller handle it.
+        if (!DOMException.isInstance(aError)) {
+          throw aError;
+        }
+        console.error("Error sweeping log folder:\n" + aError);
+      }
+    }
+  },
+
+  observe(aSubject, aTopic, aData) {
+    switch (aTopic) {
+      case "new-text":
+        let excludeBecauseEncrypted = false;
+        if (aSubject.isEncrypted) {
+          excludeBecauseEncrypted = !Services.prefs.getBoolPref(
+            "messenger.account." +
+              aSubject.conversation.account.id +
+              ".options.otrAllowMsgLog",
+            Services.prefs.getBoolPref("chat.otr.default.allowMsgLog")
+          );
+        }
+        if (!aSubject.noLog && !excludeBecauseEncrypted) {
+          let log = getLogWriter(aSubject.conversation);
+          log.logMessage(aSubject);
+        }
+        break;
+      case "conversation-closed":
+      case "conversation-left-chat":
+        closeLogWriter(aSubject);
+        break;
+      default:
+        throw new Error("Unexpected notification " + aTopic);
+    }
+  },
+
+  QueryInterface: ChromeUtils.generateQI(["nsIObserver", "imILogger"]),
+  classDescription: "Logger",
+};