Log stderr of adapters to dedicated files; improve spawn error messages

Author: mfussenegger

lua/dap.lua

@@ -26,6 +26,7 @@ local lazy = setmetatable({
 })
 
 
+---@return dap.log.Log
 local function log()
   return require('dap.log').create_logger('dap.log')
 end
@@ -429,25 +430,31 @@ local function add_reset_session_hook(lsession)
 end
 
 
-local function run_adapter(adapter, configuration, opts)
-  local name = configuration.name or '[no name]'
-  local options = adapter.options or {}
-  opts = vim.tbl_extend('keep', opts, {
-    cwd = options.cwd,
-    env = options.env
-  })
+---@param adapter dap.Adapter
+---@param config dap.Configuration
+---@param opts table
+local function run_adapter(adapter, config, opts)
+  local name = config.name or '[no name]'
   if adapter.type == 'executable' then
     lazy.progress.report('Running: ' .. name)
-    M.launch(adapter, configuration, opts)
+    ---@cast adapter dap.ExecutableAdapter
+    local options = adapter.options or {}
+    opts = vim.tbl_extend('keep', opts, {
+      cwd = options.cwd,
+      env = options.env
+    })
+    M.launch(adapter, config, opts)
   elseif adapter.type == 'server' then
     lazy.progress.report('Running: ' .. name)
-    M.attach(adapter, configuration, opts)
+    ---@cast adapter dap.ServerAdapter
+    M.attach(adapter, config, opts)
   elseif adapter.type == "pipe" then
     lazy.progress.report("Running: " .. name)
     local lsession
-    lsession = require("dap.session").pipe(adapter, opts, function(err)
+    ---@cast adapter dap.PipeAdapter
+    lsession = require("dap.session").pipe(adapter, config, opts, function(err)
       if not err then
-        lsession:initialize(configuration)
+        lsession:initialize(config)
       end
     end)
     add_reset_session_hook(lsession)
@@ -762,7 +769,7 @@ local function terminate(lsession, opts)
   end
 
   if lsession.closed then
-    log().warn('User called terminate on already closed session that is still in use')
+    log():warn('User called terminate on already closed session that is still in use')
     sessions[lsession.id] = nil
     M.set_session(nil)
     on_done()
@@ -776,7 +783,7 @@ local function terminate(lsession, opts)
     local timeout_ms = timeout_sec * 1000
     lsession:request_with_timeout('terminate', args, timeout_ms, function(err)
       if err then
-        log().warn(lazy.utils.fmt_error(err))
+        log():warn(lazy.utils.fmt_error(err))
       end
       if not lsession.closed then
         lsession:close()
@@ -839,7 +846,7 @@ function M.terminate(opts, disconnect_opts, cb)
     if not lsession then
       local _, s = next(sessions)
       if s then
-        log().info("Terminate called without active session, switched to", s.id)
+        log():info("Terminate called without active session, switched to", s.id)
       end
       lsession = s
     end
@@ -935,7 +942,7 @@ function M.list_breakpoints(openqf)
   end
   vim.fn.setqflist({}, action, {
     items = qf_list,
-    context = DAP_QUICKFIX_CONTEXT,
+    context = { DAP_QUICKFIX_CONTEXT },
     title = DAP_QUICKFIX_TITLE
   })
   if openqf then
@@ -1179,6 +1186,7 @@ function M.disconnect(opts, cb)
 end
 
 
+---@private
 --- Connect to a debug adapter via TCP
 ---@param adapter dap.ServerAdapter
 ---@param config dap.Configuration
@@ -1190,7 +1198,7 @@ function M.attach(adapter, config, opts)
   end
   assert(adapter.port, 'Adapter used with attach must have a port property')
   local s
-  s = require('dap.session'):connect(adapter, opts, function(err)
+  s = require('dap.session').connect(adapter, config, opts, function(err)
     if err then
       notify(
         string.format("Couldn't connect to %s:%s: %s", adapter.host or '127.0.0.1', adapter.port, err),
@@ -1208,13 +1216,17 @@ function M.attach(adapter, config, opts)
 end
 
 
+---@private
 --- Launch an executable debug adapter and initialize a session
 ---
 ---@param adapter dap.ExecutableAdapter
 ---@param config dap.Configuration
 ---@param opts table
 function M.launch(adapter, config, opts)
-  local s = require('dap.session'):spawn(adapter, opts)
+  local s = require('dap.session').spawn(adapter, opts, config)
+  if not s then
+    return
+  end
   add_reset_session_hook(s)
   M.set_session(s)
   s:initialize(config)
@@ -1223,7 +1235,7 @@ end
 
 
 function M.set_log_level(level)
-  log().set_level(level)
+  log():set_level(level)
 end
 
 

lua/dap/_cmds.lua

@@ -158,4 +158,13 @@ function M.yank_evalname()
 end
 
 
+function M.show_logs()
+  local log = require("dap.log")
+  log.create_logger("dap.log")
+  for _, logger in pairs(log._loggers) do
+    vim.cmd.tabnew(logger._path)
+  end
+end
+
+
 return M

lua/dap/log.lua

@@ -1,79 +1,168 @@
--- Similar to lsp/log.lua in neovim,
--- but allows to create multiple loggers with different filenames each
-
 local M = {}
+
+---@type table<string, dap.log.Log>
 local loggers = {}
 
+M._loggers = loggers
+
+---@enum dap.log.Level
 M.levels = {
-  TRACE = 0;
-  DEBUG = 1;
-  INFO  = 2;
-  WARN  = 3;
-  ERROR = 4;
+  TRACE = 0,
+  DEBUG = 1,
+  INFO  = 2,
+  WARN  = 3,
+  ERROR = 4,
 }
 
-local log_date_format = "%FT%H:%M:%SZ%z"
+local log_date_format = "!%FT%H:%M:%S"
 
-function M.create_logger(filename)
-  local logger = loggers[filename]
-  if logger then
-    return logger
+
+---@class dap.log.Log
+---@field _fname string
+---@field _path string
+---@field _file file*?
+---@field _level dap.log.Level
+
+
+---@class dap.log.Log
+local Log = {}
+local log_mt = {
+  __index = Log
+}
+
+
+function Log:write(...)
+  self:open()
+  self._file:write(...)
+end
+
+function Log:open()
+  if not self._file then
+    local f = assert(io.open(self._path, "w+"))
+    self._file = f
   end
-  logger = {}
-  loggers[filename] = logger
+end
 
+---@param level dap.log.Level|string
+function Log:set_level(level)
+  if type(level) == "string" then
+    self._level = assert(
+      M.levels[tostring(level):upper()],
+      string.format('Log level must be one of (trace, debug, info, warn, error), got: %q', level)
+    )
+  else
+    self._level = level
+  end
+end
+
+function Log:get_path()
+  return self._path
+end
+
+
+function Log:close()
+  if self._file then
+    self._file:flush()
+    self._file:close()
+    self._file = nil
+  end
+end
+
+function Log:remove()
+  self:close()
+  os.remove(self._path)
+  loggers[self._fname] = nil
+end
+
+
+---@param level dap.log.Level
+---@return boolean
+function Log:_log(level, ...)
+  local argc = select('#', ...)
+  if level < self._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 = {
+    table.concat({'[', level, ']', os.date(log_date_format), ']', fileinfo, ']'}, ' ')
+  }
+  for i = 1, argc do
+    local arg = select(i, ...)
+    if arg == nil then
+      table.insert(parts, "nil")
+    else
+      table.insert(parts, vim.inspect(arg))
+    end
+  end
+  self:write(table.concat(parts, '\t'), '\n')
+  return true
+end
+
+
+
+--- Not generating methods below in a loop to help out luals
+
+
+function Log:trace(...)
+  self:_log(M.levels.TRACE, ...)
+end
+
+function Log:debug(...)
+  self:_log(M.levels.DEBUG, ...)
+end
+
+function Log:info(...)
+  self:_log(M.levels.INFO, ...)
+end
+
+function Log:warn(...)
+  self:_log(M.levels.WARN, ...)
+end
+
+function Log:error(...)
+  self:_log(M.levels.ERROR, ...)
+end
+
+
+---@param fname string
+---@return string path
+---@return string cache_dir
+local function getpath(fname)
   local path_sep = vim.loop.os_uname().sysname == "Windows" and "\\" or "/"
   local joinpath = (vim.fs or {}).joinpath or function(...)
     ---@diagnostic disable-next-line: deprecated
     return table.concat(vim.tbl_flatten{...}, path_sep)
   end
   local cache_dir = vim.fn.stdpath('cache')
   assert(type(cache_dir) == "string")
-  local logfilename = joinpath(cache_dir, filename)
-
-  local current_log_level = M.levels.INFO
+  return joinpath(cache_dir, fname), cache_dir
+end
 
-  function logger.set_level(level)
-    current_log_level = assert(
-      M.levels[tostring(level):upper()],
-      string.format('Log level must be one of (trace, debug, info, warn, error), got: %q', level)
-    )
-  end
 
-  function logger.get_filename()
-    return logfilename
+---@return dap.log.Log
+function M.create_logger(filename)
+  local logger = loggers[filename]
+  if logger then
+    logger:open()
+    return logger
   end
+  local path, cache_dir = getpath(filename)
+  local log = {
+    _fname = filename,
+    _path = path,
+    _level = M.levels.INFO
+  }
+  logger = setmetatable(log, log_mt)
+  loggers[filename] = logger
 
   vim.fn.mkdir(cache_dir, "p")
-  local logfile = assert(io.open(logfilename, "a+"))
-  for level, levelnr in pairs(M.levels) do
-    logger[level:lower()] = function(...)
-      local argc = select('#', ...)
-      if levelnr < current_log_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 = {
-        table.concat({'[', level, ']', os.date(log_date_format), ']', fileinfo, ']'}, ' ')
-      }
-      for i = 1, argc do
-        local arg = select(i, ...)
-        if arg == nil then
-          table.insert(parts, "nil")
-        else
-          table.insert(parts, vim.inspect(arg))
-        end
-      end
-      logfile:write(table.concat(parts, '\t'), '\n')
-      logfile:flush()
-    end
-  end
-  logfile:write('\n')
+  logger:open()
   return logger
 end
 
+
 return M