basic log viewer

scripts/logviewer/file.js

@@ -0,0 +1,36 @@
+
+export function openFile(mimeType = null) {
+    const input = document.createElement("input");
+    input.setAttribute("type", "file");
+    input.className = "hidden";
+    if (mimeType) {
+        input.setAttribute("accept", mimeType);
+    }
+    const promise = new Promise((resolve, reject) => {
+        const checkFile = () => {
+            input.removeEventListener("change", checkFile, true);
+            const file = input.files[0];
+            document.body.removeChild(input);
+            if (file) {
+                resolve(file);   
+            } else {
+                reject(new Error("no file picked"));
+            }
+        }
+        input.addEventListener("change", checkFile, true);
+    });
+    // IE11 needs the input to be attached to the document
+    document.body.appendChild(input);
+    input.click();
+    return promise;
+}
+
+export function readFileAsText(file) {
+    const reader = new FileReader();
+    const promise = new Promise((resolve, reject) => {
+        reader.addEventListener("load", evt => resolve(evt.target.result));
+        reader.addEventListener("error", evt => reject(evt.target.error));
+    });
+    reader.readAsText(file);
+    return promise;
+}

scripts/logviewer/html.js

@@ -0,0 +1,110 @@
+/*
+Copyright 2020 Bruno Windels <bruno@windels.cloud>
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+// DOM helper functions
+
+export function isChildren(children) {
+    // children should be an not-object (that's the attributes), or a domnode, or an array
+    return typeof children !== "object" || !!children.nodeType || Array.isArray(children);
+}
+
+export function classNames(obj, value) {
+    return Object.entries(obj).reduce((cn, [name, enabled]) => {
+        if (typeof enabled === "function") {
+            enabled = enabled(value);
+        }
+        if (enabled) {
+            return cn + (cn.length ? " " : "") + name;
+        } else {
+            return cn;
+        }
+    }, "");
+}
+
+export function setAttribute(el, name, value) {
+    if (name === "className") {
+        name = "class";
+    }
+    if (value === false) {
+        el.removeAttribute(name);
+    } else {
+        if (value === true) {
+            value = name;
+        }
+        el.setAttribute(name, value);
+    }
+}
+
+export function el(elementName, attributes, children) {
+    return elNS(HTML_NS, elementName, attributes, children);
+}
+
+export function elNS(ns, elementName, attributes, children) {
+    if (attributes && isChildren(attributes)) {
+        children = attributes;
+        attributes = null;
+    }
+
+    const e = document.createElementNS(ns, elementName);
+
+    if (attributes) {
+        for (let [name, value] of Object.entries(attributes)) {
+            if (name === "className" && typeof value === "object" && value !== null) {
+                value = classNames(value);
+            }
+            setAttribute(e, name, value);
+        }
+    }
+
+    if (children) {
+        if (!Array.isArray(children)) {
+            children = [children];
+        }
+        for (let c of children) {
+            if (!c.nodeType) {
+                c = text(c);
+            }
+            e.appendChild(c);
+        }
+    }
+    return e;
+}
+
+export function text(str) {
+    return document.createTextNode(str);
+}
+
+export const HTML_NS = "http://www.w3.org/1999/xhtml";
+export const SVG_NS = "http://www.w3.org/2000/svg";
+
+export const TAG_NAMES = {
+    [HTML_NS]: [
+        "br", "a", "ol", "ul", "li", "div", "h1", "h2", "h3", "h4", "h5", "h6",
+        "p", "strong", "em", "span", "img", "section", "main", "article", "aside",
+        "pre", "button", "time", "input", "textarea", "label", "form", "progress", "output"],
+    [SVG_NS]: ["svg", "circle"]
+};
+
+export const tag = {};
+
+
+for (const [ns, tags] of Object.entries(TAG_NAMES)) {
+    for (const tagName of tags) {
+        tag[tagName] = function(attributes, children) {
+            return elNS(ns, tagName, attributes, children);
+        }
+    }
+}

scripts/logviewer/index.html

@@ -0,0 +1,113 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="utf-8">
+        <style type="text/css">
+            html, body {
+                height: 100%;
+            }
+
+            body {
+                font-family: sans-serif;
+                font-size: 1rem;
+                margin: 0;
+                display: grid;
+                grid-template-areas: "nav nav" "items details";
+                grid-template-columns: 1fr 400px;
+                grid-template-rows: auto 1fr;
+                min-height: 0;
+            }
+
+            main {
+              grid-area: items;
+              min-width: 0;
+              min-height: 0;
+              overflow-y: auto;
+            }
+
+            aside {
+              grid-area: details;
+            }
+
+            aside h3 {
+              word-wrap: anywhere;
+            }
+
+            aside .values li span {
+              word-wrap: ;
+              word-wrap: anywhere;
+            }
+
+            aside .values {
+              list-style: none;
+              padding: 0;
+            }
+
+            aside .values span {
+              width: 50%;
+              display: block;
+            }
+
+            aside .values li {
+              display: flex;
+              border: ;
+              border-bottom: 1px solid lightgray;
+            }
+
+            nav {
+              grid-area: nav;
+            }
+
+            .timeline ol {
+                list-style: none;
+                padding: 0 0 0 20px;
+            }
+
+            .timeline div.item {
+                --hue: 100deg;
+                --brightness: 80%;
+                background-color: hsl(var(--hue), 60%, var(--brightness));
+                border: 1px solid hsl(var(--hue), 60%, calc(var(--brightness) - 40%));
+                border-radius: 4px;
+                padding: 2px;
+                display: flex;
+                margin: 1px;
+            }
+
+            .timeline div.item .caption {
+                white-space: nowrap;
+                text-overflow: ellipsis;
+                overflow: hidden;
+                flex: 1;
+            }
+
+            .timeline div.item.level-3 {
+                --brightness: 90%;
+            }
+            
+            .timeline div.item.level-6 {
+                --hue: 0deg !important;
+            }
+
+            .timeline div.item.type-network {
+                --hue: 30deg;
+            }
+
+            .timeline div.item.selected {
+                background-color: Highlight;
+                border-color: Highlight;
+                color: HighlightText;
+            }
+
+            .hidden {
+                display: none;
+            }
+        </style>
+    </head>
+    <body>
+        <nav><button id="openFile">Open log file</button></nav>
+        <main></main>
+        <aside></aside>
+        <script type="module" src="main.js"></script>
+    </body>
+</html>

scripts/logviewer/main.js

@@ -0,0 +1,109 @@
+import {tag as t} from "./html.js";
+import {openFile, readFileAsText} from "./file.js";
+
+const main = document.querySelector("main");
+
+let selectedItemNode;
+let rootItem;
+
+document.querySelector("main").addEventListener("click", event => {
+    if (selectedItemNode) {
+        selectedItemNode.classList.remove("selected");
+        selectedItemNode = null;
+    }
+    const itemNode = event.target.closest(".item");
+    if (itemNode) {
+        selectedItemNode = itemNode;
+        selectedItemNode.classList.add("selected");
+        const path = selectedItemNode.dataset.path;
+        let item = rootItem;
+        let parent;
+        if (path.length) {
+            const indices = path.split("/").map(i => parseInt(i, 10));
+            for(const i of indices) {
+                parent = item;
+                item = itemChildren(item)[i];
+            }
+        }
+        showItemDetails(item, parent);
+    }
+});
+
+function showItemDetails(item, parent) {
+    const aside = t.aside([
+        t.h3(itemCaption(item)),
+        t.ul({class: "values"}, Object.entries(itemValues(item)).map(([key, value]) => {
+            return t.li([
+                t.span(normalizeValueKey(key)),
+                t.span(value)
+            ]);
+        }))
+    ]);
+    document.querySelector("aside").replaceWith(aside);
+}
+
+document.getElementById("openFile").addEventListener("click", loadFile);
+
+async function loadFile() {
+    const file = await openFile();
+    const json = await readFileAsText(file);
+    const logs = JSON.parse(json);
+    rootItem = {c: logs.items};
+    const fragment = logs.items.reduce((fragment, item, i, items) => {
+        const prevItem = i === 0 ? null : items[i - 1];
+        fragment.appendChild(t.section([
+            t.h2(prevItem ? `+ ${itemStart(item) - itemEnd(prevItem)} ms` : new Date(itemStart(item)).toString()),
+            t.div({className: "timeline"}, t.ol(itemToNode(item, [i])))
+        ]));
+        return fragment;
+    }, document.createDocumentFragment());
+    main.replaceChildren(fragment);
+}
+
+function itemChildren(item) { return item.c; }
+function itemStart(item) { return item.s; }
+function itemEnd(item) { return item.s + item.d; }
+function itemDuration(item) { return item.d; }
+function itemValues(item) { return item.v; }
+function itemLevel(item) { return item.l; }
+function itemLabel(item) { return item.v?.l; }
+function itemType(item) { return item.v?.t; }
+function itemError(item) { return item.e; }
+function itemCaption(item) {
+    if (itemType(item) === "network") {
+        return `${itemValues(item)?.method} ${itemValues(item)?.url}`;
+    } else if (itemLabel(item) && itemValues(item)?.id) {
+        return `${itemLabel(item)} ${itemValues(item).id}`;
+    } else {
+        return itemLabel(item) || itemType(item);
+    }
+}
+function normalizeValueKey(key) {
+    switch (key) {
+        case "t": return "type";
+        case "l": return "label";
+        default: return key;
+    }
+} 
+
+// returns the node and the total range (recursively) occupied by the node
+function itemToNode(item, path) {
+    const className = {
+        item: true,
+        error: itemError(item),
+        [`type-${itemType(item)}`]: !!itemType(item),
+        [`level-${itemLevel(item)}`]: true,
+    };
+    const li = t.li([
+        t.div({className, "data-path": path.join("/")}, [
+            t.span({class: "caption"}, itemCaption(item)),
+            t.span({class: "duration"}, `(${itemDuration(item)}ms)`),
+        ])
+    ]);
+    if (itemChildren(item) && itemChildren(item).length) {
+        li.appendChild(t.ol(itemChildren(item).map((item, i) => {
+            return itemToNode(item, path.concat(i));
+        })));
+    }
+    return li;
+}