refactor: rewrite logger

Author: boltlessengineer

lua/rest-nvim/client/curl.lua

@@ -11,6 +11,7 @@ local client = {}
 local found_curl, curl = pcall(require, "cURL.safe")
 
 local utils = require("rest-nvim.utils")
+local logger = require("rest-nvim.logger")
 
 -- TODO: add support for submitting forms in the `client.request` function
 
@@ -116,15 +117,12 @@ end
 ---@param statistics_tbl RestConfigResultStats Statistics table
 ---@return table Request statistics
 local function get_stats(req, statistics_tbl)
-  local logger = _G._rest_nvim.logger
-
   local stats = {}
 
   local function get_stat(req_, stat_)
     local curl_info = curl["INFO_" .. stat_:upper()]
     if not curl_info then
-      ---@diagnostic disable-next-line need-check-nil
-      logger:error(
+      logger.error(
         "The cURL request stat field '"
           .. stat_("' was not found.\nPlease take a look at: https://curl.se/libcurl/c/curl_easy_getinfo.html")
       )
@@ -163,10 +161,9 @@ end
 ---@return table? info The request information (url, method, headers, body, etc)
 function client.request_(request)
   local info = {}
-  local logger = assert(_G._rest_nvim.logger)
   if not found_curl then
     ---@diagnostic disable-next-line need-check-nil
-    logger:error("lua-curl could not be found, therefore the cURL client will not work.")
+    logger.error("lua-curl could not be found, therefore the cURL client will not work.")
     return
   end
   local host = request.headers["host"]
@@ -248,7 +245,7 @@ function client.request_(request)
       end
       req:setopt_httppost(form)
     else
-      logger:error(("'%s' type body is not supported yet"):format(request.body.__TYPE))
+      logger.error(("'%s' type body is not supported yet"):format(request.body.__TYPE))
       return
     end
   end
@@ -273,7 +270,7 @@ function client.request_(request)
     info.headers = table.concat(res_headers):gsub("\r", "")
     info.body = table.concat(res_result)
   else
-    logger:error("Something went wrong when making the request with cURL:\n" .. curl_error(err:no()))
+    logger.error("Something went wrong when making the request with cURL:\n" .. curl_error(err:no()))
     return
   end
   req:close()

lua/rest-nvim/commands.lua

@@ -36,6 +36,8 @@ local commands = {}
 
 local dotenv = require("rest-nvim.dotenv")
 local request = require("rest-nvim.request")
+local logger = require("rest-nvim.logger")
+
 
 ---@type table<string, RestCmd>
 local rest_command_tbl = {
@@ -111,10 +113,8 @@ local function rest(opts)
   local args = #fargs > 1 and vim.list_slice(fargs, 2, #fargs) or {}
   local command = rest_command_tbl[cmd]
 
-  local logger = assert(_G._rest_nvim.logger)
-
   if not command then
-    logger:error("Unknown command: " .. cmd)
+    logger.error("Unknown command: " .. cmd)
     return
   end
 

lua/rest-nvim/config/init.lua

@@ -65,7 +65,6 @@ local logger = require("rest-nvim.logger")
 ---@field result RestConfigResult Request results buffer behavior
 ---@field highlight RestConfigHighlight Request highlighting
 ---@field _debug_info? RestConfigDebug Configurations debug information, set automatically
----@field logger? Logger Logging system, set automatically
 
 ---rest.nvim default configuration
 ---@type RestConfig
@@ -132,6 +131,7 @@ local default_config = {
     enable = true,
     timeout = 750,
   },
+  _log_level = vim.log.levels.WARN,
 }
 
 ---Set user-defined configurations for rest.nvim
@@ -148,19 +148,13 @@ function config.set(user_configs)
 
   local ok, err = check.validate(conf)
 
-  -- We do not want to validate `logger` value so we are setting it after the validation
-  conf.logger = logger:new({
-    level_name = conf.logs.level,
-    save_logs = conf.logs.save,
-  })
-
   if not ok then
     ---@cast err string
-    conf.logger:error(err)
+    conf.logger.error(err)
   end
 
   if #conf._debug_info.unrecognized_configs > 0 then
-    conf.logger:warn("Unrecognized configs found in setup: " .. vim.inspect(conf._debug_info.unrecognized_configs))
+    conf.logger.warn("Unrecognized configs found in setup: " .. vim.inspect(conf._debug_info.unrecognized_configs))
   end
 
   return conf

lua/rest-nvim/logger.lua

@@ -2,176 +2,117 @@
 ---
 ---@brief [[
 ---
----Logging library for rest.nvim, slightly inspired by rmagatti/logger.nvim
+---Logging library for rest.nvim, inspired by nvim-neorocks/rocks.nvim
 ---Intended for use by internal and third-party modules.
 ---
----Default logger instance is made during the `setup` and can be accessed
----by anyone through the `_G._rest_nvim.logger` configuration field
----that is set automatically.
----
----------------------------------------------------------------------------------
----
----Usage:
----
----```lua
----local logger = require("rest-nvim.logger"):new({ level = "debug" })
----
----logger:set_log_level("info")
----
----logger:info("This is an info log")
---- -- [rest.nvim] INFO: This is an info log
----```
----
 ---@brief ]]
 
----@class Logger
 local logger = {}
 
--- NOTE: vim.loop has been renamed to vim.uv in Neovim >= 0.10 and will be removed later
-local uv = vim.uv or vim.loop
+---@type fun(any)
+function logger.trace(_) end
+---@type fun(any)
+function logger.debug(_) end
+---@type fun(any)
+function logger.info(_) end
+---@type fun(any)
+function logger.warn(_) end
+---@type fun(any)
+function logger.error(_) end
 
----@see vim.log.levels
----@class LoggerLevels
-local levels = {
-  trace = vim.log.levels.TRACE,
-  debug = vim.log.levels.DEBUG,
-  info = vim.log.levels.INFO,
-  warn = vim.log.levels.WARN,
-  error = vim.log.levels.ERROR,
-}
+local default_log_path = vim.fn.stdpath("log") --[[@as string]]
 
----@class LoggerConfig
----@field level_name string Logging level name. Default is `"info"`
----@field save_logs boolean Whether to save log messages into a `.log` file. Default is `true`
-local default_config = {
-  level_name = "info",
-  save_logs = true,
-}
+local LARGE = 1e9
 
-local default_log_path = vim.fn.stdpath("log") --[[@as string]]
+local log_date_format = "%F %H:%M:%S"
 
 ---Get the rest.nvim log file path.
 ---@package
 ---@return string filepath
 function logger.get_logfile()
-    return vim.fs.joinpath(default_log_path, "rest-nvim.log")
-end
-
----Store the logger output in a file at `vim.fn.stdpath("log")`
----@see vim.fn.stdpath
----@param msg string Logger message to be saved
-local function store_log(msg)
-  local date = os.date("%F %r") -- 2024-01-26 01:25:05 PM
-  local log_msg = date .. " | " .. msg .. "\n"
-  local log_path = logger.get_logfile()
-
-  -- 644 sets read and write permissions for the owner, and it sets read-only
-  -- mode for the group and others
-  uv.fs_open(log_path, "a+", tonumber(644, 8), function(err, file)
-    if file and not err then
-      local file_pipe = uv.new_pipe(false)
-      ---@cast file_pipe uv_pipe_t
-      uv.pipe_open(file_pipe, file)
-      uv.write(file_pipe, log_msg)
-      uv.fs_close(file)
-    end
-  end)
+  return vim.fs.joinpath(default_log_path, "rest-nvim.log")
 end
 
----Create a new logger instance
----@param opts LoggerConfig Logger configuration
----@return Logger
-function logger:new(opts)
-  opts = opts or {}
-  local conf = vim.tbl_deep_extend("force", default_config, opts)
-  self.level = levels[conf.level_name]
-  self.save_logs = conf.save_logs
-
-  self.__index = function(_, index)
-    if type(self[index]) == "function" then
-      return function(...)
-        -- Make any logger function call with "." access result in the syntactic sugar ":" access
-        self[index](self, ...)
-      end
-    else
-      return self[index]
-    end
+local logfile, openerr
+---@private
+---Opens log file. Returns true if file is open, false on error
+---@return boolean
+local function open_logfile()
+  -- Try to open file only once
+  if logfile then
+    return true
   end
-  setmetatable(opts, self)
-
-  return self
-end
-
----Set the log level for the logger
----@param level string New logging level
----@see vim.log.levels
-function logger:set_log_level(level)
-  self.level = levels[level]
-end
-
----Log a trace message
----@param msg string Log message
-function logger:trace(msg)
-  msg = "[rest.nvim] TRACE: " .. msg
-  if self.level == vim.log.levels.TRACE then
-    vim.notify(msg, levels.trace)
+  if openerr then
+    return false
   end
 
-  if self.save_logs then
-    store_log(msg)
+  vim.fn.mkdir(default_log_path, "-p")
+  logfile, openerr = io.open(logger.get_logfile(), "w+")
+  if not logfile then
+    local err_msg = string.format("Failed to open rest.nvim log file: %s", openerr)
+    vim.notify(err_msg, vim.log.levels.ERROR)
+    return false
   end
-end
 
----Log a debug message
----@param msg string Log message
-function logger:debug(msg)
-  msg = "[rest.nvim] DEBUG: " .. msg
-  if self.level == vim.log.levels.DEBUG then
-    vim.notify(msg, levels.debug)
+  local log_info = vim.uv.fs_stat(logger.get_logfile())
+  if log_info and log_info.size > LARGE then
+    local warn_msg =
+      string.format("rest.nvim log is large (%d MB): %s", log_info.size / (1000 * 1000), logger.get_logfile())
+    vim.notify(warn_msg, vim.log.levels.WARN)
   end
 
-  if self.save_logs then
-    store_log(msg)
-  end
+  -- Start message for logging
+  logfile:write(string.format("[START][%s] rest.nvim logging initiated\n", os.date(log_date_format)))
+  return true
 end
 
----Log an info message
----@param msg string Log message
-function logger:info(msg)
-  msg = "[rest.nvim] INFO: " .. msg
-  local valid_levels = { vim.log.levels.INFO, vim.log.levels.DEBUG }
-  if vim.tbl_contains(valid_levels, self.level) then
-    vim.notify(msg, levels.info)
-  end
-
-  if self.save_logs then
-    store_log(msg)
-  end
+local log_levels = vim.deepcopy(vim.log.levels)
+for levelstr, levelnr in pairs(log_levels) do
+  log_levels[levelnr] = levelstr
 end
 
----Log a warning message
----@param msg string Log message
-function logger:warn(msg)
-  msg = "[rest.nvim] WARN: " .. msg
-  local valid_levels = { vim.log.levels.INFO, vim.log.levels.DEBUG, vim.log.levels.WARN }
-  if vim.tbl_contains(valid_levels, self.level) then
-    vim.notify(msg, levels.warn)
-  end
-
-  if self.save_logs then
-    store_log(msg)
+---Set the log level for the logger
+---@param level (string|integer) New logging level
+---@see vim.log.levels
+function logger.set_log_level(level)
+  if type(level) == "string" then
+    logger.level = assert(log_levels[level:upper()], string.format("rest.nvim: Invalid log level: %q", level))
+  else
+    assert(log_levels[level], string.format("rest.nvim: Invalid log level: %d", level))
+    logger.level = level
   end
 end
 
----Log an error message
----@param msg string Log message
-function logger:error(msg)
-  msg = "[rest.nvim] ERROR: " .. msg
-  vim.notify(msg, levels.error)
-
-  if self.save_logs then
-    store_log(msg)
+for level, levelnr in pairs(vim.log.levels) do
+  logger[level:lower()] = function(...)
+    if logger.level == vim.log.levels.OFF or not open_logfile() then
+      return false
+    end
+    local argc = select("#", ...)
+    if levelnr < logger.level then
+      return false
+    end
+    if argc == 0 then
+      return true
+    end
+    local info = debug.getinfo(2, "Sl")
+    local fileinfo = string.format("%s:%s", info.short_src, info.currentline)
+    local parts = { level, "|", os.date(log_date_format), "|", fileinfo, "|" }
+    for i = 1, argc do
+      local arg = select(i, ...)
+      if arg == nil then
+        table.insert(parts, "<nil>")
+      elseif type(arg) == "string" then
+        table.insert(parts, arg)
+      else
+        table.insert(parts, vim.inspect(arg))
+      end
+    end
+    logfile:write(table.concat(parts, " "), "\n")
+    logfile:flush()
   end
 end
 
+logger.set_log_level(vim.tbl_get(_G, "_rest_nvim", "_log_level") or vim.log.levels.WARN)
+
 return logger