Logger.h

Go to the documentation of this file.

#pragma once
 
#include <llvm/Support/Debug.h>
#include <llvm/Support/Error.h>
#include <llvm/Support/FormatAdapters.h>
#include <llvm/Support/FormatVariadic.h>
 
#include <mutex>
 
namespace lspserver {
 
/// Interface to allow custom logging in clangd.
class Logger {
public:
  virtual ~Logger() = default;
 
  /// The significance or severity of this message.
  /// Typically used to filter the output to an interesting level.
  enum Level : unsigned char { Debug, Verbose, Info, Error };
  static char indicator(Level L) { return "DVIE"[L]; }
 
  /// Implementations of this method must be thread-safe.
  virtual void log(Level, const char *Fmt,
                   const llvm::formatv_object_base &Message) = 0;
};
 
namespace detail {
const char *debugType(const char *Filename);
void logImpl(Logger::Level, const char *Fmt, const llvm::formatv_object_base &);
 
// We often want to consume llvm::Errors by value when passing them to log().
// We automatically wrap them in llvm::fmt_consume() as formatv requires.
template <typename T> T &&wrap(T &&V) { return std::forward<T>(V); }
inline decltype(fmt_consume(llvm::Error::success())) wrap(llvm::Error &&V) {
  return fmt_consume(std::move(V));
}
template <typename... Ts>
void log(Logger::Level L, const char *Fmt, Ts &&...Vals) {
  detail::logImpl(L, Fmt,
                  llvm::formatv(Fmt, detail::wrap(std::forward<Ts>(Vals))...));
}
 
llvm::Error error(std::error_code, std::string &&);
} // namespace detail
 
// Clangd logging functions write to a global logger set by LoggingSession.
// If no logger is registered, writes to llvm::errs().
// All accept llvm::formatv()-style arguments, e.g. log("Text={0}", Text).
 
// elog() is used for "loud" errors and warnings.
// This level is often visible to users.
template <typename... Ts> void elog(const char *Fmt, Ts &&...Vals) {
  detail::log(Logger::Error, Fmt, std::forward<Ts>(Vals)...);
}
// log() is used for information important to understand a clangd session.
// e.g. the names of LSP messages sent are logged at this level.
// This level could be enabled in production builds to allow later inspection.
template <typename... Ts> void log(const char *Fmt, Ts &&...Vals) {
  detail::log(Logger::Info, Fmt, std::forward<Ts>(Vals)...);
}
// vlog() is used for details often needed for debugging clangd sessions.
// This level would typically be enabled for clangd developers.
template <typename... Ts> void vlog(const char *Fmt, Ts &&...Vals) {
  detail::log(Logger::Verbose, Fmt, std::forward<Ts>(Vals)...);
}
// error() constructs an llvm::Error object, using formatv()-style arguments.
// It is not automatically logged! (This function is a little out of place).
// The error simply embeds the message string.
template <typename... Ts>
llvm::Error error(std::error_code EC, const char *Fmt, Ts &&...Vals) {
  // We must render the formatv_object eagerly, while references are valid.
  return detail::error(
      EC, llvm::formatv(Fmt, detail::wrap(std::forward<Ts>(Vals))...).str());
}
// Overload with no error_code conversion, the error will be inconvertible.
template <typename... Ts> llvm::Error error(const char *Fmt, Ts &&...Vals) {
  return detail::error(
      llvm::inconvertibleErrorCode(),
      llvm::formatv(Fmt, detail::wrap(std::forward<Ts>(Vals))...).str());
}
// Overload to avoid formatv complexity for simple strings.
inline llvm::Error error(std::error_code EC, std::string Msg) {
  return detail::error(EC, std::move(Msg));
}
// Overload for simple strings with no error_code conversion.
inline llvm::Error error(std::string Msg) {
  return detail::error(llvm::inconvertibleErrorCode(), std::move(Msg));
}
 
/// Only one LoggingSession can be active at a time.
class LoggingSession {
public:
  LoggingSession(Logger &Instance);
  ~LoggingSession();
 
  LoggingSession(LoggingSession &&) = delete;
  LoggingSession &operator=(LoggingSession &&) = delete;
 
  LoggingSession(LoggingSession const &) = delete;
  LoggingSession &operator=(LoggingSession const &) = delete;
};
 
// Logs to an output stream, such as stderr.
class StreamLogger : public Logger {
  std::mutex LogsLock;
 
public:
  StreamLogger(llvm::raw_ostream &Logs, Logger::Level MinLevel);
 
  /// Write a line to the logging stream.
  void log(Level, const char *Fmt,
           const llvm::formatv_object_base &Message) override;
 
private:
  Logger::Level MinLevel;
  llvm::raw_ostream &Logs;
};
 
} // namespace lspserver