logster 2.11.4 → 2.12.1

data/client-app/app/models/message-collection.js

@@ -1,23 +1,26 @@
+import classic from "ember-classic-decorator";
 import { ajax, increaseTitleCount } from "client-app/lib/utilities";
 import Message from "client-app/models/message";
 import Group from "client-app/models/group";
 import { compare } from "@ember/utils";
-import { default as EmberObject, computed } from "@ember/object";
+import EmberObject, { computed } from "@ember/object";
 import { A } from "@ember/array";
 
 const BATCH_SIZE = 50;
-
 export const SEVERITIES = ["Debug", "Info", "Warn", "Err", "Fatal"];
 
-export default EmberObject.extend({
-  total: 0,
-  rows: null,
-  currentRow: null,
-  currentTab: null,
-  currentEnvPosition: 0,
-  currentGroupedMessagesPosition: 0,
-
-  filter: computed(...SEVERITIES.map(s => `show${s}`), function() {
+@classic
+export default class MessageCollection extends EmberObject {
+  total = 0;
+  rows = A();
+  currentRow = null;
+  currentTab = null;
+  currentEnvPosition = 0;
+  currentGroupedMessagesPosition = 0;
+  search = "";
+
+  @computed(...SEVERITIES.map((s) => `show${s}`))
+  get filter() {
     const filter = [];
     SEVERITIES.forEach((severity, index) => {
       if (this[`show${severity}`]) {
@@ -26,35 +29,57 @@ export default EmberObject.extend({
     });
     filter.push(5); // always show unknown, rare
     return filter;
-  }),
+  }
 
-  init() {
-    this._super(...arguments);
-    this.setProperties({
-      search: "",
-      rows: A()
-    });
-  },
-
-  currentMessage: computed(
-    "currentRow",
-    "currentGroupedMessagesPosition",
-    function() {
-      const row = this.currentRow;
-      const position = this.currentGroupedMessagesPosition;
-      if (row && row.group) {
-        return row.messages[position];
-      } else {
-        return row;
+  @computed("currentRow", "currentGroupedMessagesPosition")
+  get currentMessage() {
+    const row = this.currentRow;
+    const position = this.currentGroupedMessagesPosition;
+    if (row && row.group) {
+      return row.messages[position];
+    } else {
+      return row;
+    }
+  }
+
+  @computed("filter", "search.length")
+  get hideCountInLoadMore() {
+    const filter = this.filter;
+    return (
+      (this.search && this.search.length > 0) || (filter && filter.length < 6)
+    );
+  }
+
+  @computed("rows.length", "canLoadMore")
+  get moreBefore() {
+    return this.rows.length >= BATCH_SIZE && this.canLoadMore;
+  }
+
+  @computed("total", "rows.length")
+  get totalBefore() {
+    return this.total - this.rows.length;
+  }
+
+  @computed("search")
+  get regexSearch() {
+    const search = this.search;
+    if (search && search.length > 2 && search[0] === "/") {
+      const match = search.match(/\/(.*)\/(.*)/);
+      if (match && match.length === 3) {
+        try {
+          return new RegExp(match[1], match[2]);
+        } catch (err) {
+          // don't care
+        }
       }
     }
-  ),
+    return null;
+  }
 
-  solve(message) {
-    message.solve().then(() => {
-      this.reload();
-    });
-  },
+  async solve(message) {
+    await message.solve();
+    this.reload();
+  }
 
   selectRow(row, opts = {}) {
     const old = this.currentRow;
@@ -69,35 +94,36 @@ export default EmberObject.extend({
       currentRow: row,
       loadingEnv: false,
       currentGroupedMessagesPosition,
-      currentEnvPosition: 0
+      currentEnvPosition: 0,
     });
-    if (shouldRefresh)
+    if (shouldRefresh) {
       this.notifyPropertyChange("currentGroupedMessagesPosition");
+    }
     const forceFetchEnv = this.currentMessage && !this.currentMessage.env;
     this.fetchEnv({ force: forceFetchEnv });
-  },
+  }
 
   tabChanged(newTab) {
     this.setProperties({
       currentTab: newTab,
-      loadingEnv: false
+      loadingEnv: false,
     });
     this.fetchEnv();
-  },
+  }
 
   groupedMessageChanged(newPosition) {
     this.setProperties({
       currentGroupedMessagesPosition: newPosition,
-      currentEnvPosition: 0
+      currentEnvPosition: 0,
     });
     const forceFetchEnv = this.currentMessage && !this.currentMessage.env;
     this.fetchEnv({ force: forceFetchEnv });
-  },
+  }
 
   envChanged(newPosition) {
     this.set("currentEnvPosition", newPosition);
     this.fetchEnv();
-  },
+  }
 
   fetchEnv(opts = {}) {
     const message = this.currentMessage;
@@ -108,27 +134,27 @@ export default EmberObject.extend({
       this.set("loadingEnv", true);
       return message.fetchEnv().finally(() => this.set("loadingEnv", false));
     }
-  },
+  }
 
   findEquivalentMessageIndex(row) {
     let messageIndex = 0;
     if (
-      row &&
-      row.group &&
-      this.currentRow &&
-      this.currentRow.group &&
+      row?.group &&
+      this.currentRow?.group &&
       row.key === this.currentRow.key
     ) {
       messageIndex = row.messages.mapBy("key").indexOf(this.currentMessage.key);
       messageIndex = Math.max(0, messageIndex);
     }
+
     return messageIndex;
-  },
+  }
 
   updateSelectedRow() {
-    const currentKey = this.get("currentRow.key");
+    const currentKey = this.currentRow?.key;
+
     if (currentKey && this.rows) {
-      const match = this.rows.find(m => m.key === currentKey);
+      const match = this.rows.find((m) => m.key === currentKey);
       if (match) {
         const messageIndex = this.findEquivalentMessageIndex(match);
         this.selectRow(match, { messageIndex });
@@ -136,17 +162,17 @@ export default EmberObject.extend({
         this.setProperties({
           currentRow: null,
           currentEnvPosition: 0,
-          currentGroupedMessagesPosition: 0
+          currentGroupedMessagesPosition: 0,
         });
       }
     }
-  },
+  }
 
-  load(opts) {
-    opts = opts || {};
+  async load(opts) {
+    opts ||= {};
 
     const data = {
-      filter: this.filter.join("_")
+      filter: this.filter.join("_"),
     };
 
     if (this.search && this.search.length > 0) {
@@ -169,131 +195,109 @@ export default EmberObject.extend({
     }
 
     this.set("loading", true);
-    return ajax("/messages.json", {
-      data: data,
-      method: "POST"
-    })
-      .then(data => {
-        // guard against race: ensure the results we're trying to apply
-        //                     match the current search terms
-        if (compare(data.filter, this.filter) != 0) {
-          return;
-        }
-        if (compare(data.search, this.search) != 0) {
-          return;
-        }
 
-        if (data.messages.length > 0) {
-          const newRows = this.toObjects(data.messages);
-          const rows = this.rows;
-          if (opts.before) {
-            rows.unshiftObjects(newRows);
-          } else {
-            newRows.forEach(nrow => {
-              rows.forEach(erow => {
-                if (erow.key === nrow.key) {
-                  rows.removeObject(erow);
-                  if (this.currentRow === erow) {
-                    // TODO would updateFromJson() work here?
-                    const messageIndex = this.findEquivalentMessageIndex(nrow);
-                    this.selectRow(nrow, { messageIndex });
-                  }
-                }
-              });
-            });
-            rows.addObjects(newRows);
-            if (newRows.length > 0) {
-              increaseTitleCount(newRows.length);
+    try {
+      const response = await ajax("/messages.json", {
+        data,
+        method: "POST",
+      });
+
+      // guard against race: ensure the results we're trying to apply
+      //                     match the current search terms
+      if (compare(response.filter, this.filter) !== 0) {
+        return;
+      }
+
+      if (compare(response.search, this.search) !== 0) {
+        return;
+      }
+
+      if (response.messages.length > 0) {
+        const newRows = this.toObjects(response.messages);
+
+        if (opts.before) {
+          this.rows.unshiftObjects(newRows);
+        } else {
+          for (const newRow of newRows) {
+            for (const row of this.rows) {
+              if (row.key !== newRow.key) {
+                continue;
+              }
+
+              this.rows.removeObject(row);
+
+              if (this.currentRow === row) {
+                const messageIndex = this.findEquivalentMessageIndex(newRow);
+                this.selectRow(newRow, { messageIndex });
+              }
             }
           }
+
+          this.rows.addObjects(newRows);
+
+          if (newRows.length > 0) {
+            increaseTitleCount(newRows.length);
+          }
         }
-        this.set("total", data.total);
-        return data;
-      })
-      .finally(() => this.set("loading", false));
-  },
+      }
+
+      this.set("total", response.total);
+      return response;
+    } finally {
+      this.set("loading", false);
+    }
+  }
 
-  reload() {
+  async reload() {
     this.set("total", 0);
     this.rows.clear();
 
-    return this.load().then(data => this.updateCanLoadMore(data));
-  },
+    const data = await this.load();
+    this.updateCanLoadMore(data);
+  }
 
   updateCanLoadMore(data) {
     if (!data) {
       return;
     }
+
     if (data.messages.length < BATCH_SIZE) {
       this.set("canLoadMore", false);
     } else {
       this.set("canLoadMore", true);
     }
-  },
+  }
 
   loadMore() {
-    const rows = this.rows;
-    if (rows.length === 0) {
+    if (this.rows.length === 0) {
       this.load({});
       return;
     }
 
-    const lastLog = rows[rows.length - 1];
+    const lastLog = this.rows[this.rows.length - 1];
     const lastKey = lastLog.group ? lastLog.row_id : lastLog.key;
+
     this.load({
-      after: lastKey
+      after: lastKey,
     });
-  },
-
-  hideCountInLoadMore: computed("search", "filter", function() {
-    const filter = this.filter;
-    return (
-      (this.search && this.search.length > 0) || (filter && filter.length < 6)
-    );
-  }),
-
-  moreBefore: computed("rows.length", "canLoadMore", function() {
-    return this.get("rows.length") >= BATCH_SIZE && this.canLoadMore;
-  }),
-
-  totalBefore: computed("total", "rows.length", function() {
-    return this.total - this.rows.length;
-  }),
+  }
 
-  showMoreBefore: function() {
-    const rows = this.rows;
-    const firstLog = rows[0];
+  async showMoreBefore() {
+    const firstLog = this.rows[0];
     const firstKey = firstLog.group ? firstLog.row_id : firstLog.key;
-    const knownGroups = rows.filterBy("group").mapBy("regex");
+    const knownGroups = this.rows.filterBy("group").mapBy("regex");
 
-    this.load({
+    const data = await this.load({
       before: firstKey,
-      knownGroups
-    }).then(data => this.updateCanLoadMore(data));
-  },
+      knownGroups,
+    });
 
-  regexSearch: computed("search", function() {
-    const search = this.search;
-    if (search && search.length > 2 && search[0] === "/") {
-      const match = search.match(/\/(.*)\/(.*)/);
-      if (match && match.length === 3) {
-        try {
-          return new RegExp(match[1], match[2]);
-        } catch (err) {
-          // don't care
-        }
-      }
-    }
-    return null;
-  }),
+    this.updateCanLoadMore(data);
+  }
 
   toObjects(rows) {
-    return rows.map(m => {
-      if (m.group) {
-        return Group.create(m);
-      } else {
-        return Message.create(m);
-      }
+    return rows.map((m) => {
+      return m.group ? Group.create(m) : Message.create(m);
     });
   }
-});
+}

data/client-app/app/models/message.js

@@ -1,76 +1,49 @@
+import classic from "ember-classic-decorator";
+import { gt } from "@ember/object/computed";
+import EmberObject, { computed } from "@ember/object";
 import { ajax } from "client-app/lib/utilities";
 import { getRootPath } from "client-app/lib/preload";
-import { computed } from "@ember/object";
 
-export default Em.Object.extend({
-  MAX_LEN: 200,
+@classic
+export default class Message extends EmberObject {
+  MAX_LEN = 200;
 
-  fetchEnv() {
-    return ajax(`/fetch-env/${this.key}.json`).then(env =>
-      this.set("env", env)
-    );
-  },
+  @gt("count", 1) showCount;
 
-  expand() {
-    this.set("expanded", true);
-  },
-
-  solve() {
-    return ajax(`/solve/${this.key}`, { type: "PUT" });
-  },
-
-  destroy() {
-    return ajax(`/message/${this.key}`, { type: "DELETE" });
-  },
-
-  protect() {
-    this.set("protected", true);
-    return ajax(`/protect/${this.key}`, { type: "PUT" });
-  },
-
-  unprotect() {
-    this.set("protected", false);
-    return ajax(`/unprotect/${this.key}`, { type: "DELETE" });
-  },
-
-  showCount: computed("count", function() {
-    return this.count > 1;
-  }),
-
-  hasMore: computed("message", "expanded", function() {
+  @computed("MAX_LEN", "expanded", "message.length")
+  get hasMore() {
     return !this.expanded && this.message.length > this.MAX_LEN;
-  }),
+  }
 
-  shareUrl: computed("key", function() {
+  @computed("key")
+  get shareUrl() {
     return `${getRootPath()}/show/${this.key}`;
-  }),
+  }
 
-  displayMessage: computed("message", "expanded", function() {
+  @computed("MAX_LEN", "expanded", "message.length")
+  get displayMessage() {
     let message = this.message;
 
     if (!this.expanded && this.message.length > this.MAX_LEN) {
       message = this.message.substr(0, this.MAX_LEN);
     }
     return message;
-  }),
-
-  updateFromObject(other) {
-    // XXX Only updatable property is count right now
-    this.set("count", other.get("count"));
-  },
+  }
 
-  canSolve: computed("env.{application_version,length}", function() {
+  @computed("backtrace.length", "env.{application_version,length}")
+  get canSolve() {
     const appVersion = Array.isArray(this.env)
       ? this.env
-          .map(e => e.application_version)
+          .map((e) => e.application_version)
           .compact()
           .join("")
       : this.env && this.env.application_version;
     return appVersion && this.backtrace && this.backtrace.length > 0;
-  }),
+  }
 
-  rowClass: computed("severity", function() {
-    switch (this.get("severity")) {
+  @computed("severity")
+  get rowClass() {
+    switch (this.severity) {
       case 0:
         return "debug";
       case 1:
@@ -84,9 +57,10 @@ export default Em.Object.extend({
       default:
         return "unknown";
     }
-  }),
+  }
 
-  glyph: computed("severity", function() {
+  @computed("severity")
+  get glyph() {
     switch (this.severity) {
       case 0:
         return "";
@@ -101,13 +75,14 @@ export default Em.Object.extend({
       default:
         return "question-circle";
     }
-  }),
+  }
 
-  prefix: computed(function() {
+  get prefix() {
     return "fas";
-  }),
+  }
 
-  klass: computed("severity", function() {
+  @computed("severity")
+  get klass() {
     switch (this.severity) {
       case 0:
         return "";
@@ -122,5 +97,32 @@ export default Em.Object.extend({
       default:
         return "unknown";
     }
-  })
-});
+  }
+
+  async fetchEnv() {
+    const env = await ajax(`/fetch-env/${this.key}.json`);
+    this.set("env", env);
+  }
+
+  expand() {
+    this.set("expanded", true);
+  }
+
+  solve() {
+    return ajax(`/solve/${this.key}`, { type: "PUT" });
+  }
+
+  destroy() {
+    return ajax(`/message/${this.key}`, { type: "DELETE" });
+  }
+
+  protect() {
+    this.set("protected", true);
+    return ajax(`/protect/${this.key}`, { type: "PUT" });
+  }
+
+  unprotect() {
+    this.set("protected", false);
+    return ajax(`/unprotect/${this.key}`, { type: "DELETE" });
+  }
+}

data/client-app/app/models/pattern-item.js

@@ -1,30 +1,32 @@
-import { default as EmberObject, computed } from "@ember/object";
+import classic from "ember-classic-decorator";
+import { lte } from "@ember/object/computed";
+import EmberObject, { computed } from "@ember/object";
 
-export default EmberObject.extend({
-  isNew: false,
-  value: "",
-  valueBuffer: "",
-  error: null,
-  saving: false,
-  count: 0,
+@classic
+export default class PatternItem extends EmberObject {
+  isNew = false;
+  value = "";
+  valueBuffer = "";
+  error = null;
+  saving = false;
+  count = 0;
+
+  @lte("count", 0) zeroCount;
 
   init() {
-    this._super(...arguments);
-    this.set("valueBuffer", this.get("value"));
-  },
+    super.init(...arguments);
+    this.set("valueBuffer", this.value);
+  }
+
+  @computed("value", "valueBuffer")
+  get hasBuffer() {
+    return this.value !== this.valueBuffer;
+  }
 
   updateValue(newValue) {
     this.setProperties({
       value: newValue,
-      valueBuffer: newValue
+      valueBuffer: newValue,
     });
-  },
-
-  hasBuffer: computed("value", "valueBuffer", function() {
-    return this.get("value") !== this.get("valueBuffer");
-  }),
-
-  zeroCount: computed("count", function() {
-    return this.get("count") <= 0;
-  })
-});
+  }
+}

data/client-app/app/router.js

@@ -1,12 +1,12 @@
 import EmberRouter from "@ember/routing/router";
-import config from "./config/environment";
+import config from "client-app/config/environment";
 
 export default class Router extends EmberRouter {
   location = config.locationType;
   rootURL = config.rootURL;
 }
 
-Router.map(function() {
+Router.map(function () {
   this.route("index", { path: "/" });
   this.route("show", { path: "/show/:id" });
   this.route("settings");