Swift: remove Log::configure

Author: redsun82

swift/extractor/infra/log/SwiftLogging.cpp

@@ -96,15 +96,14 @@ void collectSeverityRules(const char* var, LevelConfiguration&& configuration) {
 
 }  // namespace
 
-void Log::configureImpl(std::string_view root) {
-  rootName = root;
+void Log::configure() {
   // as we are configuring logging right now, we collect problems and log them at the end
   std::vector<std::string> problems;
   collectSeverityRules("CODEQL_EXTRACTOR_SWIFT_LOG_LEVELS",
                        {sourceRules, binary.level, text.level, console.level, problems});
   if (text || binary) {
     std::filesystem::path logFile = getEnvOr("CODEQL_EXTRACTOR_SWIFT_LOG_DIR", ".");
-    logFile /= root;
+    logFile /= logRootName;
     logFile /= std::to_string(std::chrono::system_clock::now().time_since_epoch().count());
     std::error_code ec;
     std::filesystem::create_directories(logFile.parent_path(), ec);
@@ -145,11 +144,15 @@ void Log::flushImpl() {
 }
 
 Log::LoggerConfiguration Log::getLoggerConfigurationImpl(std::string_view name) {
-  LoggerConfiguration ret{session, rootName};
+  LoggerConfiguration ret{session, logRootName};
   ret.fullyQualifiedName += '/';
   ret.fullyQualifiedName += name;
   ret.level = std::min({binary.level, text.level, console.level});
   ret.level = getLevelFor(ret.fullyQualifiedName, sourceRules, ret.level);
+  // avoid Logger constructor loop
+  if (name != "logging") {
+    LOG_DEBUG("Configuring logger {} with level {}", ret.fullyQualifiedName, ret.level);
+  }
   return ret;
 }
 
@@ -161,7 +164,7 @@ Log& Log::write(const char* buffer, std::streamsize size) {
 }
 
 Logger& Log::logger() {
-  static Logger ret{"logging"};
+  static Logger ret{getLoggerConfigurationImpl("logging")};
   return ret;
 }
 

swift/extractor/infra/log/SwiftLogging.h

@@ -8,6 +8,9 @@
 #include <binlog/binlog.hpp>
 #include <binlog/TextOutputStream.hpp>
 #include <binlog/EventFilter.hpp>
+#include <binlog/adapt_stdfilesystem.hpp>
+#include <binlog/adapt_stdoptional.hpp>
+#include <binlog/adapt_stdvariant.hpp>
 
 // Logging macros. These will call `logger()` to get a Logger instance, picking up any `logger`
 // defined in the current scope. Domain-specific loggers can be added or used by either:
@@ -64,10 +67,22 @@
 
 namespace codeql {
 
+// tools should define this to tweak the root name of all loggers
+extern const char* const logRootName;
+
 // This class is responsible for the global log state (outputs, log level rules, flushing)
 // State is stored in the singleton `Log::instance()`.
 // Before using logging, `Log::configure("<name>")` should be used (e.g.
 // `Log::configure("extractor")`). Then, `Log::flush()` should be regularly called.
+// Logging is configured upon first usage.  This consists in
+//  * using environment variable `CODEQL_EXTRACTOR_SWIFT_LOG_DIR` to choose where to dump the log
+//    file(s). Log files will go to a subdirectory thereof named after `logRootName`
+//  * using environment variable `CODEQL_EXTRACTOR_SWIFT_LOG_LEVELS` to configure levels for
+//    loggers and outputs. This must have the form of a comma separated `spec:level` list, where
+//    `spec` is either a glob pattern (made up of alphanumeric, `/`, `*` and `.` characters) for
+//    matching logger names or one of `out:bin`, `out:text` or `out:console`.
+//    Output default levels can be seen in the corresponding initializers below. By default, all
+//    loggers are configured with the lowest output level
 class Log {
  public:
   using Level = binlog::Severity;
@@ -79,17 +94,6 @@ class Log {
     Level level;
   };
 
-  // Configure logging. This consists in
-  // * using environment variable `CODEQL_EXTRACTOR_SWIFT_LOG_DIR` to choose where to dump the log
-  //   file(s). Log files will go to a subdirectory thereof named after `root`
-  // * using environment variable `CODEQL_EXTRACTOR_SWIFT_LOG_LEVELS` to configure levels for
-  //   loggers and outputs. This must have the form of a comma separated `spec:level` list, where
-  //   `spec` is either a glob pattern (made up of alphanumeric, `/`, `*` and `.` characters) for
-  //   matching logger names or one of `out:bin`, `out:text` or `out:console`.
-  //   Output default levels can be seen in the corresponding initializers below. By default, all
-  //   loggers are configured with the lowest output level
-  static void configure(std::string_view root) { instance().configureImpl(root); }
-
   // Flush logs to the designated outputs
   static void flush() { instance().flushImpl(); }
 
@@ -101,16 +105,16 @@ class Log {
  private:
   static constexpr const char* format = "%u %S [%n] %m (%G:%L)\n";
 
-  Log() = default;
+  Log() { configure(); }
 
   static Log& instance() {
     static Log ret;
     return ret;
   }
 
-  static class Logger& logger();
+  class Logger& logger();
 
-  void configureImpl(std::string_view root);
+  void configure();
   void flushImpl();
   LoggerConfiguration getLoggerConfigurationImpl(std::string_view name);
 
@@ -148,19 +152,24 @@ class Log {
   FilteredOutput<binlog::TextOutputStream> text{Level::info, textFile, format};
   FilteredOutput<binlog::TextOutputStream> console{Level::warning, std::cerr, format};
   LevelRules sourceRules;
-  std::string rootName;
 };
 
 // This class represent a named domain-specific logger, responsible for pushing logs using the
 // underlying `binlog::SessionWriter` class. This has a configured log level, so that logs on this
 // `Logger` with a level lower than the configured one are no-ops. The level is configured based
-// on rules matching `<root name>/<name>` in `CODEQL_EXTRACTOR_SWIFT_LOG_LEVELS` (see above).
-// `<root name>` is what is provided to the global `Log::configure`, `<name>` is provided in the
-// constructor. If no rule matches the name, the log level defaults to the minimum level of all
-// outputs.
+// on rules matching `<logRootName>/<name>` in `CODEQL_EXTRACTOR_SWIFT_LOG_LEVELS` (see above).
+// `<name>` is provided in the constructor. If no rule matches the name, the log level defaults to
+// the minimum level of all outputs.
 class Logger {
  public:
-  explicit Logger(const std::string& name) : Logger(Log::getLoggerConfiguration(name)) {}
+  // configured logger based on name, as explained above
+  explicit Logger(std::string_view name) : Logger(Log::getLoggerConfiguration(name)) {}
+
+  // used internally, public to be accessible to Log for its own logger
+  explicit Logger(Log::LoggerConfiguration&& configuration)
+      : w{configuration.session, queueSize, /* id */ 0,
+          std::move(configuration.fullyQualifiedName)},
+        level_{configuration.level} {}
 
   binlog::SessionWriter& writer() { return w; }
   Log::Level level() const { return level_; }
@@ -172,11 +181,6 @@ class Logger {
  private:
   static constexpr size_t queueSize = 1 << 20;  // default taken from binlog
 
-  explicit Logger(Log::LoggerConfiguration&& configuration)
-      : w{configuration.session, queueSize, /* id */ 0,
-          std::move(configuration.fullyQualifiedName)},
-        level_{configuration.level} {}
-
   binlog::SessionWriter w;
   Log::Level level_;
 };

swift/extractor/main.cpp

@@ -20,6 +20,8 @@
 
 using namespace std::string_literals;
 
+const char* const codeql::logRootName = "extractor";
+
 // must be called before processFrontendOptions modifies output paths
 static void lockOutputSwiftModuleTraps(codeql::SwiftExtractorState& state,
                                        const swift::FrontendOptions& options) {
@@ -214,7 +216,6 @@ int main(int argc, char** argv, char** envp) {
   initializeSwiftModules();
 
   const auto configuration = configure(argc, argv);
-  codeql::Log::configure("extractor");
   {
     codeql::Logger logger{"main"};
     LOG_INFO("calling extractor with arguments \"{}\"", argDump(argc, argv));