feat(wezterm): massively overhaul logging utilities

dots/.config/wezterm/config/gpu.lua

@@ -2,11 +2,12 @@
 -- we are unable to locate a card that supports Vulkan we fall back to OpenGL
 local config = {}
 local wezterm = require("wezterm")
+local log = require("lib.log")
 
 local found_valid_gpu = false
 for _, gpu in ipairs(wezterm.gui.enumerate_gpus()) do
     if gpu.backend == "Vulkan" and not found_valid_gpu then
-        wezterm.log_info(
+        log.info(
             "Found Usable Vulkan GPU -- Device Name -> " .. gpu.name .. "; Device Type -> " .. gpu.device_type
         )
         config.webgpu_preferred_adapter = gpu
@@ -17,7 +18,7 @@ for _, gpu in ipairs(wezterm.gui.enumerate_gpus()) do
 end
 
 if not found_valid_gpu then
-    wezterm.log_warn("Unable to locate a Vulkan-supported GPU, falling back to OpenGL")
+    log.warn("Unable to locate a Vulkan-supported GPU, falling back to OpenGL")
     config.front_end = "OpenGL"
 end
 

dots/.config/wezterm/lib/inspect.lua

@@ -0,0 +1,368 @@
+-- Taken from and thanks to https://github.com/kikito/inspect.lua
+
+local _tl_compat
+if (tonumber((_VERSION or ""):match("[%d.]*$")) or 0) < 5.3 then
+    local p, m = pcall(require, "compat53.module")
+    if p then
+        _tl_compat = m
+    end
+end
+local math = _tl_compat and _tl_compat.math or math
+local string = _tl_compat and _tl_compat.string or string
+local table = _tl_compat and _tl_compat.table or table
+local inspect = { Options = {} }
+
+inspect._VERSION = "inspect.lua 3.1.0"
+inspect._URL = "http://github.com/kikito/inspect.lua"
+inspect._DESCRIPTION = "human-readable representations of tables"
+inspect._LICENSE = [[
+  MIT LICENSE
+
+  Copyright (c) 2022 Enrique García Cota
+
+  Permission is hereby granted, free of charge, to any person obtaining a
+  copy of this software and associated documentation files (the
+  "Software"), to deal in the Software without restriction, including
+  without limitation the rights to use, copy, modify, merge, publish,
+  distribute, sublicense, and/or sell copies of the Software, and to
+  permit persons to whom the Software is furnished to do so, subject to
+  the following conditions:
+
+  The above copyright notice and this permission notice shall be included
+  in all copies or substantial portions of the Software.
+
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+  OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+  CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+  TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+  SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+]]
+inspect.KEY = setmetatable({}, {
+    __tostring = function()
+        return "inspect.KEY"
+    end,
+})
+inspect.METATABLE = setmetatable({}, {
+    __tostring = function()
+        return "inspect.METATABLE"
+    end,
+})
+
+local tostring = tostring
+local rep = string.rep
+local match = string.match
+local char = string.char
+local gsub = string.gsub
+local fmt = string.format
+
+local _rawget
+if rawget then
+    _rawget = rawget
+else
+    _rawget = function(t, k)
+        return t[k]
+    end
+end
+
+local function rawpairs(t)
+    return next, t, nil
+end
+
+local function smartQuote(str)
+    if match(str, '"') and not match(str, "'") then
+        return "'" .. str .. "'"
+    end
+    return '"' .. gsub(str, '"', '\\"') .. '"'
+end
+
+local shortControlCharEscapes = {
+    ["\a"] = "\\a",
+    ["\b"] = "\\b",
+    ["\f"] = "\\f",
+    ["\n"] = "\\n",
+    ["\r"] = "\\r",
+    ["\t"] = "\\t",
+    ["\v"] = "\\v",
+    ["\127"] = "\\127",
+}
+local longControlCharEscapes = { ["\127"] = "\127" }
+for i = 0, 31 do
+    local ch = char(i)
+    if not shortControlCharEscapes[ch] then
+        shortControlCharEscapes[ch] = "\\" .. i
+        longControlCharEscapes[ch] = fmt("\\%03d", i)
+    end
+end
+
+local function escape(str)
+    return (gsub(gsub(gsub(str, "\\", "\\\\"), "(%c)%f[0-9]", longControlCharEscapes), "%c", shortControlCharEscapes))
+end
+
+local luaKeywords = {
+    ["and"] = true,
+    ["break"] = true,
+    ["do"] = true,
+    ["else"] = true,
+    ["elseif"] = true,
+    ["end"] = true,
+    ["false"] = true,
+    ["for"] = true,
+    ["function"] = true,
+    ["goto"] = true,
+    ["if"] = true,
+    ["in"] = true,
+    ["local"] = true,
+    ["nil"] = true,
+    ["not"] = true,
+    ["or"] = true,
+    ["repeat"] = true,
+    ["return"] = true,
+    ["then"] = true,
+    ["true"] = true,
+    ["until"] = true,
+    ["while"] = true,
+}
+
+local function isIdentifier(str)
+    return type(str) == "string" and not not str:match("^[_%a][_%a%d]*$") and not luaKeywords[str]
+end
+
+local flr = math.floor
+local function isSequenceKey(k, sequenceLength)
+    return type(k) == "number" and flr(k) == k and 1 <= k and k <= sequenceLength
+end
+
+local defaultTypeOrders = {
+    ["number"] = 1,
+    ["boolean"] = 2,
+    ["string"] = 3,
+    ["table"] = 4,
+    ["function"] = 5,
+    ["userdata"] = 6,
+    ["thread"] = 7,
+}
+
+local function sortKeys(a, b)
+    local ta, tb = type(a), type(b)
+
+    if ta == tb and (ta == "string" or ta == "number") then
+        return a < b
+    end
+
+    local dta = defaultTypeOrders[ta] or 100
+    local dtb = defaultTypeOrders[tb] or 100
+
+    return dta == dtb and ta < tb or dta < dtb
+end
+
+local function getKeys(t)
+    local seqLen = 1
+    while _rawget(t, seqLen) ~= nil do
+        seqLen = seqLen + 1
+    end
+    seqLen = seqLen - 1
+
+    local keys, keysLen = {}, 0
+    for k in rawpairs(t) do
+        if not isSequenceKey(k, seqLen) then
+            keysLen = keysLen + 1
+            keys[keysLen] = k
+        end
+    end
+    table.sort(keys, sortKeys)
+    return keys, keysLen, seqLen
+end
+
+local function countCycles(x, cycles)
+    if type(x) == "table" then
+        if cycles[x] then
+            cycles[x] = cycles[x] + 1
+        else
+            cycles[x] = 1
+            for k, v in rawpairs(x) do
+                countCycles(k, cycles)
+                countCycles(v, cycles)
+            end
+            countCycles(getmetatable(x), cycles)
+        end
+    end
+end
+
+local function makePath(path, a, b)
+    local newPath = {}
+    local len = #path
+    for i = 1, len do
+        newPath[i] = path[i]
+    end
+
+    newPath[len + 1] = a
+    newPath[len + 2] = b
+
+    return newPath
+end
+
+local function processRecursive(process, item, path, visited)
+    if item == nil then
+        return nil
+    end
+    if visited[item] then
+        return visited[item]
+    end
+
+    local processed = process(item, path)
+    if type(processed) == "table" then
+        local processedCopy = {}
+        visited[item] = processedCopy
+        local processedKey
+
+        for k, v in rawpairs(processed) do
+            processedKey = processRecursive(process, k, makePath(path, k, inspect.KEY), visited)
+            if processedKey ~= nil then
+                processedCopy[processedKey] = processRecursive(process, v, makePath(path, processedKey), visited)
+            end
+        end
+
+        local mt = processRecursive(process, getmetatable(processed), makePath(path, inspect.METATABLE), visited)
+        if type(mt) ~= "table" then
+            mt = nil
+        end
+        setmetatable(processedCopy, mt)
+        processed = processedCopy
+    end
+    return processed
+end
+
+local function puts(buf, str)
+    buf.n = buf.n + 1
+    buf[buf.n] = str
+end
+
+local Inspector = {}
+
+local Inspector_mt = { __index = Inspector }
+
+local function tabify(inspector)
+    puts(inspector.buf, inspector.newline .. rep(inspector.indent, inspector.level))
+end
+
+function Inspector:getId(v)
+    local id = self.ids[v]
+    local ids = self.ids
+    if not id then
+        local tv = type(v)
+        id = (ids[tv] or 0) + 1
+        ids[v], ids[tv] = id, id
+    end
+    return tostring(id)
+end
+
+function Inspector:putValue(v)
+    local buf = self.buf
+    local tv = type(v)
+    if tv == "string" then
+        puts(buf, smartQuote(escape(v)))
+    elseif tv == "number" or tv == "boolean" or tv == "nil" or tv == "cdata" or tv == "ctype" then
+        puts(buf, tostring(v))
+    elseif tv == "table" and not self.ids[v] then
+        local t = v
+
+        if t == inspect.KEY or t == inspect.METATABLE then
+            puts(buf, tostring(t))
+        elseif self.level >= self.depth then
+            puts(buf, "{...}")
+        else
+            if self.cycles[t] > 1 then
+                puts(buf, fmt("<%d>", self:getId(t)))
+            end
+
+            local keys, keysLen, seqLen = getKeys(t)
+
+            puts(buf, "{")
+            self.level = self.level + 1
+
+            for i = 1, seqLen + keysLen do
+                if i > 1 then
+                    puts(buf, ",")
+                end
+                if i <= seqLen then
+                    puts(buf, " ")
+                    self:putValue(t[i])
+                else
+                    local k = keys[i - seqLen]
+                    tabify(self)
+                    if isIdentifier(k) then
+                        puts(buf, k)
+                    else
+                        puts(buf, "[")
+                        self:putValue(k)
+                        puts(buf, "]")
+                    end
+                    puts(buf, " = ")
+                    self:putValue(t[k])
+                end
+            end
+
+            local mt = getmetatable(t)
+            if type(mt) == "table" then
+                if seqLen + keysLen > 0 then
+                    puts(buf, ",")
+                end
+                tabify(self)
+                puts(buf, "<metatable> = ")
+                self:putValue(mt)
+            end
+
+            self.level = self.level - 1
+
+            if keysLen > 0 or type(mt) == "table" then
+                tabify(self)
+            elseif seqLen > 0 then
+                puts(buf, " ")
+            end
+
+            puts(buf, "}")
+        end
+    else
+        puts(buf, fmt("<%s %d>", tv, self:getId(v)))
+    end
+end
+
+function inspect.inspect(root, options)
+    options = options or {}
+
+    local depth = options.depth or math.huge
+    local newline = options.newline or "\n"
+    local indent = options.indent or "  "
+    local process = options.process
+
+    if process then
+        root = processRecursive(process, root, {}, {})
+    end
+
+    local cycles = {}
+    countCycles(root, cycles)
+
+    local inspector = setmetatable({
+        buf = { n = 0 },
+        ids = {},
+        cycles = cycles,
+        depth = depth,
+        level = 0,
+        newline = newline,
+        indent = indent,
+    }, Inspector_mt)
+
+    inspector:putValue(root)
+
+    return table.concat(inspector.buf)
+end
+
+setmetatable(inspect, {
+    __call = function(_, root, options)
+        return inspect.inspect(root, options)
+    end,
+})
+
+return inspect

dots/.config/wezterm/lib/log.lua

@@ -0,0 +1,54 @@
+local wezterm = require("wezterm")
+local os_detected = require("lib.wlib").get_os_arch().name:lower()
+
+local M = {}
+
+---comment
+---@param message string
+---@param log_level string
+---| "info"
+---| "debug"
+---| "warning"
+---| "err"
+local function system_log(message, log_level)
+    local log_unit = "wezterm"
+    if os_detected == "linux" then
+        print(string.format("systemd-cat -t %s -p %s echo '%s'", log_unit, log_level:lower(), message))
+        local handle = io.popen(string.format("systemd-cat -t %s -p %s echo '%s'", log_unit, log_level:lower(), message))
+        ---@diagnostic disable-next-line: need-check-nil
+        local output = handle:read("*a")
+
+        if output == nil then
+            output = "Handle did not return any content!"
+        end
+
+        ---@diagnostic disable-next-line: need-check-nil
+        local success = handle:close()
+        if success == nil or not success then
+            wezterm.log_warn(
+                string.format("'systemd-cat' did not indicate a successful run!\nHandle Output:\n%s", output)
+            )
+        end
+    end
+end
+
+function M.debug(message)
+    system_log(message, "debug")
+end
+
+function M.info(message)
+    wezterm.log_info(message)
+    system_log(message, "info")
+end
+
+function M.warn(message)
+    wezterm.log_warn(message)
+    system_log(message, "warning")
+end
+
+function M.error(message)
+    wezterm.log_error(message)
+    system_log(message, "err")
+end
+
+return M

dots/.config/wezterm/wezterm.lua

@@ -1,5 +1,6 @@
 local wezterm = require("wezterm")
-local wlib = require("wlib")
+local wlib = require("lib.wlib")
+local log = require("lib.log")
 
 -- NOTE: Should be merged
 -- NOTE: base configuration
@@ -15,10 +16,10 @@ local gpu = require("config.gpu")
 -- NOTE: Pull in the OS specific config, this is passed last to the mergeable
 -- NOTE: as the last item to be merged (last item passed) overrides all others
 local os_config_mod = "config.os." .. wlib.get_os_arch().name:lower()
-wezterm.log_info("Loading os config from " .. os_config_mod)
+log.info("Loading os config from " .. os_config_mod)
 local found, os_config = pcall(require, os_config_mod)
 if not found then
-    wezterm.log_warn("Could not load a os config from " .. os_config_mod)
+    log.warn("Could not load a os config from " .. os_config_mod)
     -- Empty out os_config if we can't find a valid configuration, won't
     -- override any settings
     os_config = {}
@@ -26,4 +27,6 @@ end
 
 local config = wlib.Table.merge(gpu, events, fonts, theme, tabbar, misc, rendering, keybinds, os_config)
 
+log.debug("Final Wezterm Config:\n" .. require("lib.inspect").inspect(config, { newline = " ", indent = "" }))
+
 return config