folly::LoggerDB Class Reference

#include <LoggerDB.h>

Classes
struct	HandlerInfo

Public Types
enum	TestConstructorArg { TESTING }
using	InternalWarningHandler = void(*)(folly::StringPiece file, int lineNumber, std::string &&)

Public Member Functions
	~LoggerDB ()
LogCategory *	getCategory (folly::StringPiece name)
LogCategory *FOLLY_NULLABLE	getCategoryOrNull (folly::StringPiece name)
void	setLevel (folly::StringPiece name, LogLevel level, bool inherit=true)
void	setLevel (LogCategory *category, LogLevel level, bool inherit=true)
LogConfig	getConfig () const
LogConfig	getFullConfig () const
void	updateConfig (const LogConfig &config)
void	resetConfig (const LogConfig &config)
void	cleanupHandlers ()
size_t	flushAllHandlers ()
void	registerHandlerFactory (std::unique_ptr< LogHandlerFactory > factory, bool replaceExisting=false)
void	unregisterHandlerFactory (folly::StringPiece type)
LogLevel	xlogInit (folly::StringPiece categoryName, std::atomic< LogLevel > *xlogCategoryLevel, LogCategory **xlogCategory)
LogCategory *	xlogInitCategory (folly::StringPiece categoryName, LogCategory **xlogCategory, std::atomic< bool > *isInitialized)
	LoggerDB (TestConstructorArg)

Static Public Member Functions
static LoggerDB &	get ()
template<typename... Args>
static void	internalWarning (folly::StringPiece file, int lineNumber, Args &&...args) noexcept
static void	setInternalWarningHandler (InternalWarningHandler handler)

Private Types
using	LoggerNameMap = std::unordered_map< folly::StringPiece, std::unique_ptr< LogCategory >, LogName::Hash, LogName::Equals >
using	HandlerFactoryMap = std::unordered_map< std::string, std::unique_ptr< LogHandlerFactory >>
using	HandlerMap = std::unordered_map< std::string, std::weak_ptr< LogHandler >>
using	NewHandlerMap = std::unordered_map< std::string, std::shared_ptr< LogHandler >>
using	OldToNewHandlerMap = std::unordered_map< std::shared_ptr< LogHandler >, std::shared_ptr< LogHandler >>

Private Member Functions
	LoggerDB (LoggerDB const &)=delete
LoggerDB &	operator= (LoggerDB const &)=delete
	LoggerDB ()
LogCategory *	getOrCreateCategoryLocked (LoggerNameMap &loggersByName, folly::StringPiece name)
LogCategory *	createCategoryLocked (LoggerNameMap &loggersByName, folly::StringPiece name, LogCategory *parent)
LogConfig	getConfigImpl (bool includeAllCategories) const
void	startConfigUpdate (const Synchronized< HandlerInfo >::LockedPtr &handlerInfo, const LogConfig &config, NewHandlerMap *handlers, OldToNewHandlerMap *oldToNewHandlerMap)
void	finishConfigUpdate (const Synchronized< HandlerInfo >::LockedPtr &handlerInfo, NewHandlerMap *handlers, OldToNewHandlerMap *oldToNewHandlerMap)
std::vector< std::shared_ptr< LogHandler > >	buildCategoryHandlerList (const NewHandlerMap &handlerMap, StringPiece categoryName, const std::vector< std::string > &categoryHandlerNames)

Static Private Member Functions
static void	internalWarningImpl (folly::StringPiece filename, int lineNumber, std::string &&msg) noexcept
static void	defaultInternalWarningImpl (folly::StringPiece filename, int lineNumber, std::string &&msg) noexcept

Private Attributes
folly::Synchronized< LoggerNameMap >	loggersByName_
folly::Synchronized< HandlerInfo >	handlerInfo_

Static Private Attributes
static std::atomic< InternalWarningHandler >	warningHandler_

Detailed Description

LoggerDB stores the set of LogCategory objects.

Definition at line 40 of file LoggerDB.h.

Member Typedef Documentation

using folly::LoggerDB::HandlerFactoryMap = std::unordered_map<std::string, std::unique_ptr<LogHandlerFactory>>

private

Definition at line 234 of file LoggerDB.h.

using folly::LoggerDB::HandlerMap = std::unordered_map<std::string, std::weak_ptr<LogHandler>>

private

Definition at line 235 of file LoggerDB.h.

using folly::LoggerDB::InternalWarningHandler = void (*)(folly::StringPiece file, int lineNumber, std::string&&)

Definition at line 210 of file LoggerDB.h.

using folly::LoggerDB::LoggerNameMap = std::unordered_map< folly::StringPiece, std::unique_ptr<LogCategory>, LogName::Hash, LogName::Equals>

private

Definition at line 231 of file LoggerDB.h.

using folly::LoggerDB::NewHandlerMap = std::unordered_map<std::string, std::shared_ptr<LogHandler>>

private

Definition at line 255 of file LoggerDB.h.

using folly::LoggerDB::OldToNewHandlerMap = std:: unordered_map<std::shared_ptr<LogHandler>, std::shared_ptr<LogHandler>>

private

Definition at line 257 of file LoggerDB.h.

Member Enumeration Documentation

enum folly::LoggerDB::TestConstructorArg

Enumerator
TESTING

Definition at line 176 of file LoggerDB.h.

{ TESTING };

Constructor & Destructor Documentation

folly::LoggerDB::~LoggerDB

(

)

Definition at line 131 of file LoggerDB.cpp.

{}

folly::LoggerDB::LoggerDB ( TestConstructorArg  )

explicit

Construct a LoggerDB for testing purposes.

Most callers should not need this function, and should use LoggerDB::get() to obtain the main LoggerDB singleton. This function exists mainly to allow testing LoggerDB objects in unit tests. It requires an explicit argument just to prevent callers from calling it unintentionally.

Definition at line 129 of file LoggerDB.cpp.

: LoggerDB() {}

folly::LoggerDB::LoggerDB ( LoggerDB const &  )

privatedelete

folly::LoggerDB::LoggerDB ( )

private

Definition at line 118 of file LoggerDB.cpp.

References folly::kDefaultLogLevel, and folly::gen::move.

                   {
  // Create the root log category and set its log level
  auto rootUptr = std::make_unique<LogCategory>(this);
  LogCategory* root = rootUptr.get();
  auto ret =
      loggersByName_.wlock()->emplace(root->getName(), std::move(rootUptr));
  DCHECK(ret.second);

  root->setLevelLocked(kDefaultLogLevel, false);
}

Member Function Documentation

std::vector< std::shared_ptr< LogHandler > > folly::LoggerDB::buildCategoryHandlerList ( const NewHandlerMap &  handlerMap, StringPiece  categoryName, const std::vector< std::string > &  categoryHandlerNames  )

private

Definition at line 372 of file LoggerDB.cpp.

Referenced by resetConfig(), and updateConfig().

                                                      {
  std::vector<std::shared_ptr<LogHandler>> catHandlers;
  for (const auto& handlerName : categoryHandlerNames) {
    auto iter = handlerMap.find(handlerName);
    if (iter == handlerMap.end()) {
      // This really shouldn't be possible; the checks in startConfigUpdate()
      // should have already bailed out if there was an unknown handler.
      throw std::invalid_argument(to<std::string>(
          "bug: unknown log handler \"",
          handlerName,
          "\" configured for log category \"",
          categoryName,
          "\""));
    }
    catHandlers.push_back(iter->second);
  }

  return catHandlers;
}

void folly::LoggerDB::cleanupHandlers

(

)

Remove all registered LogHandlers on all LogCategory objects.

This is called on the main LoggerDB object during shutdown.

Definition at line 520 of file LoggerDB.cpp.

References handlerInfo_, and loggersByName_.

                               {
  // Get a copy of all categories, so we can call clearHandlers() without
  // holding the loggersByName_ lock.  We don't need to worry about LogCategory
  // lifetime, since LogCategory objects always live for the lifetime of the
  // LoggerDB.
  std::vector<LogCategory*> categories;
  {
    auto loggersByName = loggersByName_.wlock();
    categories.reserve(loggersByName->size());
    for (const auto& entry : *loggersByName) {
      categories.push_back(entry.second.get());
    }
  }

  // Also extract our HandlerFactoryMap and HandlerMap, so we can clear them
  // later without holding the handlerInfo_ lock.
  HandlerFactoryMap factories;
  HandlerMap handlers;
  {
    auto handlerInfo = handlerInfo_.wlock();
    factories.swap(handlerInfo->factories);
    handlers.swap(handlerInfo->handlers);
  }

  // Remove all of the LogHandlers from all log categories,
  // to drop any shared_ptr references to the LogHandlers
  for (auto* category : categories) {
    category->clearHandlers();
  }
}

LogCategory * folly::LoggerDB::createCategoryLocked ( LoggerNameMap &  loggersByName, folly::StringPiece  name, LogCategory *  parent  )

private

Definition at line 509 of file LoggerDB.cpp.

References folly::gen::move, name, and parent.

Referenced by getOrCreateCategoryLocked().

                         {
  auto uptr = std::make_unique<LogCategory>(name, parent);
  LogCategory* logger = uptr.get();
  auto ret = loggersByName.emplace(logger->getName(), std::move(uptr));
  DCHECK(ret.second);
  return logger;
}

void folly::LoggerDB::defaultInternalWarningImpl ( folly::StringPiece  filename, int  lineNumber, std::string &&  msg  )

staticprivatenoexcept

Definition at line 679 of file LoggerDB.cpp.

References folly::kIsDebug, and folly::writeFull().

Referenced by internalWarningImpl().

                              {
  // Rate limit to 10 messages every 5 seconds.
  //
  // We intentonally use a leaky Meyer's singleton here over folly::Singleton:
  // - We want this code to work even before main()
  // - This singleton does not depend on any other singletons.
  static auto* rateLimiter =
      new logging::IntervalRateLimiter{10, std::chrono::seconds(5)};
  if (!rateLimiter->check()) {
    return;
  }

  if (folly::kIsDebug) {
    // Write directly to file descriptor 2.
    //
    // It's possible the application has closed fd 2 and is using it for
    // something other than stderr.  However we have no good way to detect
    // this, which is the main reason we only write to stderr in debug build
    // modes.  assert() also writes directly to stderr on failure, which seems
    // like a reasonable precedent.
    //
    // Another option would be to use openlog() and syslog().  However
    // calling openlog() may inadvertently affect the behavior of other parts
    // of the program also using syslog().
    //
    // We don't check for write errors here, since there's not much else we can
    // do if it fails.
    auto fullMsg = folly::to<std::string>(
        "logging warning:", filename, ":", lineNumber, ": ", msg, "\n");
    folly::writeFull(STDERR_FILENO, fullMsg.data(), fullMsg.size());
  }
}

void folly::LoggerDB::finishConfigUpdate ( const Synchronized< HandlerInfo >::LockedPtr &  handlerInfo, NewHandlerMap *  handlers, OldToNewHandlerMap *  oldToNewHandlerMap  )

private

Update handlerInfo_ at the end of a config update operation.

Definition at line 346 of file LoggerDB.cpp.

References folly::Synchronized< T, Mutex >::swap().

Referenced by resetConfig(), and updateConfig().

                                            {
  // Build a new map to replace handlerInfo->handlers
  // This will contain only the LogHandlers that are still in use by the
  // current LogCategory settings.
  std::unordered_map<std::string, std::weak_ptr<LogHandler>> newHandlerMap;
  for (const auto& entry : *handlers) {
    newHandlerMap.emplace(entry.first, entry.second);
  }
  // Drop all of our shared_ptr references to LogHandler objects,
  // and then remove entries in newHandlerMap that are unreferenced.
  handlers->clear();
  oldToNewHandlerMap->clear();
  handlerInfo->handlers.clear();
  for (auto iter = newHandlerMap.begin(); iter != newHandlerMap.end(); ) {
    if (iter->second.expired()) {
      iter = newHandlerMap.erase(iter);
    } else {
      ++iter;
    }
  }
  handlerInfo->handlers.swap(newHandlerMap);
}

size_t folly::LoggerDB::flushAllHandlers

(

)

Call flush() on all LogHandler objects registered on any LogCategory in this LoggerDB.

Returns the number of registered LogHandlers.

Definition at line 551 of file LoggerDB.cpp.

References handler(), and loggersByName_.

Referenced by folly::LogCategory::admitMessage().

                                  {
  // Build a set of all LogHandlers.  We use a set to avoid calling flush()
  // more than once on the same handler if it is registered on multiple
  // different categories.
  std::set<std::shared_ptr<LogHandler>> handlers;
  {
    auto loggersByName = loggersByName_.wlock();
    for (const auto& entry : *loggersByName) {
      for (const auto& handler : entry.second->getHandlers()) {
        handlers.emplace(handler);
      }
    }
  }

  // Call flush() on each handler
  for (const auto& handler : handlers) {
    handler->flush();
  }
  return handlers.size();
}

LoggerDB & folly::LoggerDB::get ( )

static

Get the main LoggerDB singleton.

Definition at line 112 of file LoggerDB.cpp.

References folly::singleton.

Referenced by folly::XlogCategoryInfo< IsInHeaderFile >::init(), folly::initLogging(), folly::XlogLevelInfo< IsInHeaderFile >::loadLevelFull(), folly::Logger::Logger(), TEST(), and TEST_F().

                        {
  // Intentionally leaky singleton
  static LoggerDBSingleton singleton{new LoggerDB()};
  return singleton.getDB();
}

LogCategory * folly::LoggerDB::getCategory

(

folly::StringPiece

name

)

Get the LogCategory for the specified name.

This creates the LogCategory for the specified name if it does not exist already.

Definition at line 133 of file LoggerDB.cpp.

References getOrCreateCategoryLocked(), loggersByName_, and name.

Referenced by folly::Logger::Logger(), and TEST_F().

                                                   {
  return getOrCreateCategoryLocked(*loggersByName_.wlock(), name);
}

LogCategory *FOLLY_NULLABLE folly::LoggerDB::getCategoryOrNull

(

folly::StringPiece

name

)

Get the LogCategory for the specified name, if it already exists.

This returns nullptr if no LogCategory has been created yet for the specified name.

Definition at line 137 of file LoggerDB.cpp.

References loggersByName_.

                                                                        {
  auto loggersByName = loggersByName_.rlock();

  auto it = loggersByName->find(name);
  if (it == loggersByName->end()) {
    return nullptr;
  }
  return it->second.get();
}

LogConfig folly::LoggerDB::getConfig

(

)

const

Get a LogConfig object describing the current state of the LoggerDB.

Definition at line 158 of file LoggerDB.cpp.

References getConfigImpl().

Referenced by TEST().

                                    {
  return getConfigImpl(/* includeAllCategories = */ false);
}

LogConfig folly::LoggerDB::getConfigImpl ( bool  includeAllCategories ) const

private

Definition at line 166 of file LoggerDB.cpp.

References handler(), handlerInfo_, loggersByName_, folly::MAX_LEVEL, folly::gen::move, and name.

Referenced by getConfig(), and getFullConfig().

                                                                 {
  auto handlerInfo = handlerInfo_.rlock();

  LogConfig::HandlerConfigMap handlerConfigs;
  std::unordered_map<std::shared_ptr<LogHandler>, string> handlersToName;
  for (const auto& entry : handlerInfo->handlers) {
    auto handler = entry.second.lock();
    if (!handler) {
      continue;
    }
    handlersToName.emplace(handler, entry.first);
    handlerConfigs.emplace(entry.first, handler->getConfig());
  }

  size_t anonymousNameIndex = 1;
  auto generateAnonymousHandlerName = [&]() {
    // Return a unique name of the form "anonymousHandlerN"
    // Keep incrementing N until we find a name that isn't currently taken.
    while (true) {
      auto name = to<string>("anonymousHandler", anonymousNameIndex);
      ++anonymousNameIndex;
      if (handlerInfo->handlers.find(name) == handlerInfo->handlers.end()) {
        return name;
      }
    }
  };

  LogConfig::CategoryConfigMap categoryConfigs;
  {
    auto loggersByName = loggersByName_.rlock();
    for (const auto& entry : *loggersByName) {
      auto* category = entry.second.get();
      auto levelInfo = category->getLevelInfo();
      auto handlers = category->getHandlers();

      // Don't report categories that have default settings
      // if includeAllCategories is false
      if (!includeAllCategories && handlers.empty() &&
          levelInfo.first == LogLevel::MAX_LEVEL && levelInfo.second) {
        continue;
      }

      // Translate the handler pointers to names
      std::vector<string> handlerNames;
      for (const auto& handler : handlers) {
        auto iter = handlersToName.find(handler);
        if (iter == handlersToName.end()) {
          // This LogHandler must have been manually attached to the category,
          // rather than defined with `updateConfig()` or `resetConfig()`.
          // Generate a unique name to use for reporting it in the config.
          auto name = generateAnonymousHandlerName();
          handlersToName.emplace(handler, name);
          handlerConfigs.emplace(name, handler->getConfig());
          handlerNames.emplace_back(name);
        } else {
          handlerNames.emplace_back(iter->second);
        }
      }

      LogCategoryConfig categoryConfig(
          levelInfo.first, levelInfo.second, handlerNames);
      categoryConfigs.emplace(category->getName(), std::move(categoryConfig));
    }
  }

  return LogConfig{std::move(handlerConfigs), std::move(categoryConfigs)};
}

LogConfig folly::LoggerDB::getFullConfig

(

)

const

Get a LogConfig object fully describing the state of the LoggerDB.

This is similar to getConfig(), but it returns LogCategoryConfig objects for all defined log categories, including ones that are using the default configuration settings.

Definition at line 162 of file LoggerDB.cpp.

References getConfigImpl().

                                        {
  return getConfigImpl(/* includeAllCategories = */ true);
}

LogCategory * folly::LoggerDB::getOrCreateCategoryLocked ( LoggerNameMap &  loggersByName, folly::StringPiece  name  )

private

Definition at line 496 of file LoggerDB.cpp.

References createCategoryLocked(), folly::LogName::getParent(), and parent.

Referenced by getCategory(), resetConfig(), setLevel(), updateConfig(), xlogInit(), and xlogInitCategory().

                      {
  auto it = loggersByName.find(name);
  if (it != loggersByName.end()) {
    return it->second.get();
  }

  StringPiece parentName = LogName::getParent(name);
  LogCategory* parent = getOrCreateCategoryLocked(loggersByName, parentName);
  return createCategoryLocked(loggersByName, name, parent);
}

template<typename... Args>

static void folly::LoggerDB::internalWarning ( folly::StringPiece  file, int  lineNumber, Args &&...  args  )

inlinestaticnoexcept

internalWarning() is used to report a problem when something goes wrong internally in the logging library.

We can't log these messages through the normal logging flow since logging itself has failed.

Example scenarios where this is used:

• We fail to write to a log file (for instance, when the disk is full)
• A LogHandler throws an unexpected exception

Definition at line 201 of file LoggerDB.h.

Referenced by folly::AsyncFileWriter::onIoError(), folly::LogCategory::processMessage(), and folly::ImmediateFileWriter::writeMessage().

                               {
    internalWarningImpl(
        file, lineNumber, folly::to<std::string>(std::forward<Args>(args)...));
  }

void folly::LoggerDB::internalWarningImpl ( folly::StringPiece  filename, int  lineNumber, std::string &&  msg  )

staticprivatenoexcept

Definition at line 644 of file LoggerDB.cpp.

References defaultInternalWarningImpl(), handler(), folly::gen::move, and warningHandler_.

                              {
  auto handler = warningHandler_.load();
  if (handler) {
    handler(filename, lineNumber, std::move(msg));
  } else {
    defaultInternalWarningImpl(filename, lineNumber, std::move(msg));
  }
}

LoggerDB& folly::LoggerDB::operator= ( LoggerDB const &  )

privatedelete

void folly::LoggerDB::registerHandlerFactory	(	std::unique_ptr< LogHandlerFactory >	factory,
		bool	replaceExisting = false
	)

Register a LogHandlerFactory.

The LogHandlerFactory will be used to create LogHandler objects from a LogConfig object during updateConfig() and resetConfig() calls.

Only one factory can be registered for a given handler type name. LogHandlerFactory::getType() returns the handler type supported by this LogHandlerFactory.

If an existing LogHandlerFactory is already registered with this type name and replaceExisting is false a std::range_error will be thrown. Otherwise, if replaceExisting is true, the new factory will replace the existing factory.

Definition at line 572 of file LoggerDB.cpp.

References handlerInfo_, folly::gen::move, and type.

Referenced by folly::initializeLoggerDB().

                          {
  auto type = factory->getType();
  auto handlerInfo = handlerInfo_.wlock();
  if (replaceExisting) {
    handlerInfo->factories[type.str()] = std::move(factory);
  } else {
    auto ret = handlerInfo->factories.emplace(type.str(), std::move(factory));
    if (!ret.second) {
      throw std::range_error(to<std::string>(
          "a LogHandlerFactory for the type \"", type, "\" already exists"));
    }
  }
}

void folly::LoggerDB::resetConfig

(

const LogConfig &

config

)

Reset the current LoggerDB state to the specified LogConfig settings.

All LogCategories not mentioned in the new LogConfig will have all currently configured log handlers removed and their log level set to its default state. For the root category the default log level is kDefaultLogLevel (see LogLevel.h); for all other categories the default level is MAX_LEVEL with log level inheritance enabled.

LogCategories listed in the new config but without LogHandler information defined will have all existing handlers removed.

Definition at line 435 of file LoggerDB.cpp.

References buildCategoryHandlerList(), finishConfigUpdate(), folly::LogConfig::getCategoryConfigs(), getOrCreateCategoryLocked(), handlerInfo_, folly::kDefaultLogLevel, loggersByName_, folly::MAX_LEVEL, folly::gen::move, and startConfigUpdate().

                                                  {
  // Grab the handlerInfo_ lock.
  // We hold it in write mode for the entire config update operation.  This
  // ensures that only a single config update operation ever runs at once.
  auto handlerInfo = handlerInfo_.wlock();

  NewHandlerMap handlers;
  OldToNewHandlerMap oldToNewHandlerMap;
  startConfigUpdate(handlerInfo, config, &handlers, &oldToNewHandlerMap);

  // Make sure all log categories mentioned in the new config exist.
  // This ensures that we will cover them in our walk below.
  LogCategory* rootCategory;
  {
    auto loggersByName = loggersByName_.wlock();
    rootCategory = getOrCreateCategoryLocked(*loggersByName, "");
    for (const auto& entry : config.getCategoryConfigs()) {
      getOrCreateCategoryLocked(*loggersByName, entry.first);
    }
  }

  {
    // Update all log categories
    auto loggersByName = loggersByName_.rlock();
    for (const auto& entry : *loggersByName) {
      auto* category = entry.second.get();

      auto configIter = config.getCategoryConfigs().find(category->getName());
      if (configIter == config.getCategoryConfigs().end()) {
        // This category is not listed in the config settings.
        // Reset it to the default settings.
        category->clearHandlers();

        if (category == rootCategory) {
          category->setLevelLocked(kDefaultLogLevel, false);
        } else {
          category->setLevelLocked(LogLevel::MAX_LEVEL, true);
        }
        continue;
      }

      const auto& catConfig = configIter->second;

      // Update the category log level
      category->setLevelLocked(catConfig.level, catConfig.inheritParentLevel);

      // Update the category handlers list.
      // If the handler list is not set in the config, clear out any existing
      // handlers rather than leaving it as-is.
      std::vector<std::shared_ptr<LogHandler>> catHandlers;
      if (catConfig.handlers.hasValue()) {
        catHandlers = buildCategoryHandlerList(
            handlers, entry.first, catConfig.handlers.value());
      }
      category->replaceHandlers(std::move(catHandlers));
    }
  }

  finishConfigUpdate(handlerInfo, &handlers, &oldToNewHandlerMap);
}

void folly::LoggerDB::setInternalWarningHandler ( InternalWarningHandler  handler )

static

Set a function to be called when the logging library generates an internal warning.

The supplied handler should never throw exceptions.

If a null handler is supplied, the default built-in handler will be used.

The default handler reports the message with _CrtDbgReport(_CRT_WARN) on Windows, and prints the message to stderr on other platforms. It also rate limits messages if they are arriving too quickly.

Definition at line 656 of file LoggerDB.cpp.

References warningHandler_.

Referenced by TEST().

                                                                       {
  // This API is intentionally pretty basic.  It has a number of limitations:
  //
  // - We only support plain function pointers, and not full std::function
  //   objects.  This makes it possible to use std::atomic to access the
  //   handler pointer, and also makes it safe to store in a zero-initialized
  //   file-static pointer.
  //
  // - We don't support any void* argument to the handler.  The caller is
  //   responsible for storing any callback state themselves.
  //
  // - When replacing or unsetting a handler we don't make any guarantees about
  //   when the old handler will stop being called.  It may still be called
  //   from other threads briefly even after setInternalWarningHandler()
  //   returns.  This is also a consequence of using std::atomic rather than a
  //   full lock.
  //
  // This provides the minimum capabilities needed to customize the handler,
  // while still keeping the implementation simple and safe to use even before
  // main().
  warningHandler_.store(handler);
}

void folly::LoggerDB::setLevel	(	folly::StringPiece	name,
		LogLevel	level,
		bool	inherit = true
	)

Set the log level for the specified category.

Messages logged to a specific log category will be ignored unless the message log level is greater than the LogCategory's effective log level.

If inherit is true, LogCategory's effective log level is the minimum of its level and it's parent category's effective log level. If inherit is false, the LogCategory's effective log level is simply its log level. (Setting inherit to false is necessary if you want a child LogCategory to use a less verbose level than its parent categories.)

Definition at line 147 of file LoggerDB.cpp.

References getOrCreateCategoryLocked(), loggersByName_, and folly::LogCategory::setLevelLocked().

Referenced by folly::LogCategory::setLevel(), and TEST_F().

                                                                           {
  auto loggersByName = loggersByName_.wlock();
  LogCategory* category = getOrCreateCategoryLocked(*loggersByName, name);
  category->setLevelLocked(level, inherit);
}

void folly::LoggerDB::setLevel	(	LogCategory *	category,
		LogLevel	level,
		bool	inherit = true
	)

Definition at line 153 of file LoggerDB.cpp.

References loggersByName_, and folly::LogCategory::setLevelLocked().

                                                                           {
  auto loggersByName = loggersByName_.wlock();
  category->setLevelLocked(level, inherit);
}

void folly::LoggerDB::startConfigUpdate ( const Synchronized< HandlerInfo >::LockedPtr &  handlerInfo, const LogConfig &  config, NewHandlerMap *  handlers, OldToNewHandlerMap *  oldToNewHandlerMap  )

private

Process handler config information when starting a config update operation.

Definition at line 237 of file LoggerDB.cpp.

References folly::exceptionStr(), folly::LogConfig::getCategoryConfigs(), folly::LogConfig::getHandlerConfigs(), handler(), folly::Optional< Value >::hasValue(), folly::gen::move, folly::LogHandlerConfig::options, folly::LogHandlerConfig::type, folly::LogHandlerConfig::update(), and folly::Optional< Value >::value().

Referenced by resetConfig(), and updateConfig().

                                            {
  // Get a map of all currently existing LogHandlers.
  // This resolves weak_ptrs to shared_ptrs, and ignores expired weak_ptrs.
  // This prevents any of these LogHandler pointers from expiring during the
  // config update.
  for (const auto& entry : handlerInfo->handlers) {
    auto handler = entry.second.lock();
    if (handler) {
      handlers->emplace(entry.first, std::move(handler));
    }
  }

  // Create all of the new LogHandlers needed from this configuration
  for (const auto& entry : config.getHandlerConfigs()) {
    // Check to see if there is an existing LogHandler with this name
    std::shared_ptr<LogHandler> oldHandler;
    auto iter = handlers->find(entry.first);
    if (iter != handlers->end()) {
      oldHandler = iter->second;
    }

    LogHandlerConfig updatedConfig;
    const LogHandlerConfig* handlerConfig;
    if (entry.second.type.hasValue()) {
      handlerConfig = &entry.second;
    } else {
      // This configuration is intended to update an existing LogHandler
      if (!oldHandler) {
        throw std::invalid_argument(to<std::string>(
            "cannot update unknown log handler \"", entry.first, "\""));
      }

      updatedConfig = oldHandler->getConfig();
      if (!updatedConfig.type.hasValue()) {
        // This normally should not happen unless someone improperly manually
        // constructed a LogHandler object.  All existing LogHandler objects
        // should indicate their type.
        throw std::invalid_argument(to<std::string>(
            "existing log handler \"",
            entry.first,
            "\" is missing type information"));
      }
      updatedConfig.update(entry.second);
      handlerConfig = &updatedConfig;
    }

    // Look up the LogHandlerFactory
    auto factoryIter = handlerInfo->factories.find(handlerConfig->type.value());
    if (factoryIter == handlerInfo->factories.end()) {
      throw std::invalid_argument(to<std::string>(
          "unknown log handler type \"", handlerConfig->type.value(), "\""));
    }

    // Create the new log handler
    const auto& factory = factoryIter->second;
    std::shared_ptr<LogHandler> handler;
    try {
      if (oldHandler) {
        handler = factory->updateHandler(oldHandler, handlerConfig->options);
        if (handler != oldHandler) {
          oldToNewHandlerMap->emplace(oldHandler, handler);
        }
      } else {
        handler = factory->createHandler(handlerConfig->options);
      }
    } catch (const std::exception& ex) {
      // Errors creating or updating the the log handler are generally due to
      // bad configuration options.  It is useful to update the exception
      // message to include the name of the log handler we were trying to
      // update or create.
      throw std::invalid_argument(to<string>(
          "error ",
          oldHandler ? "updating" : "creating",
          " log handler \"",
          entry.first,
          "\": ",
          exceptionStr(ex)));
    }
    handlerInfo->handlers[entry.first] = handler;
    (*handlers)[entry.first] = handler;
  }

  // Before we start making any LogCategory changes, confirm that all handlers
  // named in the category configs are known handlers.
  for (const auto& entry : config.getCategoryConfigs()) {
    if (!entry.second.handlers.hasValue()) {
      continue;
    }
    for (const auto& handlerName : entry.second.handlers.value()) {
      auto iter = handlers->find(handlerName);
      if (iter == handlers->end()) {
        throw std::invalid_argument(to<std::string>(
            "unknown log handler \"",
            handlerName,
            "\" configured for log category \"",
            entry.first,
            "\""));
      }
    }
  }
}

void folly::LoggerDB::unregisterHandlerFactory

(

folly::StringPiece

type

)

Remove a registered LogHandlerFactory.

The type parameter should be the name of the handler type, as returned by LogHandlerFactory::getType().

Throws std::range_error if no handler factory with this type name exists.

Definition at line 588 of file LoggerDB.cpp.

References handlerInfo_, and folly::Range< Iter >::str().

                                                        {
  auto handlerInfo = handlerInfo_.wlock();
  auto numRemoved = handlerInfo->factories.erase(type.str());
  if (numRemoved != 1) {
    throw std::range_error(
        to<std::string>("no LogHandlerFactory for type \"", type, "\" found"));
  }
}

void folly::LoggerDB::updateConfig

(

const LogConfig &

config

)

Update the current LoggerDB state with the specified LogConfig settings.

Log categories and handlers listed in the LogConfig object will be updated to the new state listed in the LogConfig. Settings on categories and handlers not listed in the config will be left as-is.

Definition at line 395 of file LoggerDB.cpp.

References buildCategoryHandlerList(), finishConfigUpdate(), folly::LogConfig::getCategoryConfigs(), getOrCreateCategoryLocked(), handlerInfo_, loggersByName_, folly::gen::move, folly::LogCategory::replaceHandlers(), folly::LogCategory::setLevelLocked(), and startConfigUpdate().

Referenced by folly::initializeLoggerDB(), and folly::initLogging().

                                                   {
  // Grab the handlerInfo_ lock.
  // We hold it in write mode for the entire config update operation.  This
  // ensures that only a single config update operation ever runs at once.
  auto handlerInfo = handlerInfo_.wlock();

  NewHandlerMap handlers;
  OldToNewHandlerMap oldToNewHandlerMap;
  startConfigUpdate(handlerInfo, config, &handlers, &oldToNewHandlerMap);

  // If an existing LogHandler was replaced with a new one,
  // walk all current LogCategories and replace this handler.
  if (!oldToNewHandlerMap.empty()) {
    auto loggerMap = loggersByName_.rlock();
    for (const auto& entry : *loggerMap) {
      entry.second->updateHandlers(oldToNewHandlerMap);
    }
  }

  // Update log levels and handlers mentioned in the config update
  auto loggersByName = loggersByName_.wlock();
  for (const auto& entry : config.getCategoryConfigs()) {
    LogCategory* category =
        getOrCreateCategoryLocked(*loggersByName, entry.first);

    // Update the log handlers
    if (entry.second.handlers.hasValue()) {
      auto catHandlers = buildCategoryHandlerList(
          handlers, entry.first, entry.second.handlers.value());
      category->replaceHandlers(std::move(catHandlers));
    }

    // Update the level settings
    category->setLevelLocked(
        entry.second.level, entry.second.inheritParentLevel);
  }

  finishConfigUpdate(handlerInfo, &handlers, &oldToNewHandlerMap);
}

LogLevel folly::LoggerDB::xlogInit	(	folly::StringPiece	categoryName,
		std::atomic< LogLevel > *	xlogCategoryLevel,
		LogCategory **	xlogCategory
	)

Initialize the LogCategory* and std::atomic<LogLevel> used by an XLOG() statement.

Returns the current effective LogLevel of the category.

Definition at line 597 of file LoggerDB.cpp.

References folly::LogCategory::getEffectiveLevel(), getOrCreateCategoryLocked(), and loggersByName_.

Referenced by folly::XlogCategoryInfo< IsInHeaderFile >::init(), and folly::XlogLevelInfo< IsInHeaderFile >::loadLevelFull().

                                {
  // Hold the lock for the duration of the operation
  // xlogInit() may be called from multiple threads simultaneously.
  // Only one needs to perform the initialization.
  auto loggersByName = loggersByName_.wlock();
  if (xlogCategory != nullptr && *xlogCategory != nullptr) {
    // The xlogCategory was already initialized before we acquired the lock
    return (*xlogCategory)->getEffectiveLevel();
  }

  auto* category = getOrCreateCategoryLocked(*loggersByName, categoryName);
  if (xlogCategory) {
    // Set *xlogCategory before we update xlogCategoryLevel below.
    // This is important, since the XLOG() macros check xlogCategoryLevel to
    // tell if *xlogCategory has been initialized yet.
    *xlogCategory = category;
  }
  auto level = category->getEffectiveLevel();
  xlogCategoryLevel->store(level, std::memory_order_release);
  category->registerXlogLevel(xlogCategoryLevel);
  return level;
}

LogCategory * folly::LoggerDB::xlogInitCategory	(	folly::StringPiece	categoryName,
		LogCategory **	xlogCategory,
		std::atomic< bool > *	isInitialized
	)

Definition at line 623 of file LoggerDB.cpp.

References getOrCreateCategoryLocked(), loggersByName_, and warningHandler_.

Referenced by folly::XlogCategoryInfo< IsInHeaderFile >::init().

                                    {
  // Hold the lock for the duration of the operation
  // xlogInitCategory() may be called from multiple threads simultaneously.
  // Only one needs to perform the initialization.
  auto loggersByName = loggersByName_.wlock();
  if (isInitialized->load(std::memory_order_acquire)) {
    // The xlogCategory was already initialized before we acquired the lock
    return *xlogCategory;
  }

  auto* category = getOrCreateCategoryLocked(*loggersByName, categoryName);
  *xlogCategory = category;
  isInitialized->store(true, std::memory_order_release);
  return category;
}

Member Data Documentation

folly::Synchronized<HandlerInfo> folly::LoggerDB::handlerInfo_

private

The LogHandlers and LogHandlerFactories.

For lock ordering purposes, if you need to acquire both the loggersByName_ and handlerInfo_ locks, the handlerInfo_ lock must be acquired first.

Definition at line 296 of file LoggerDB.h.

Referenced by cleanupHandlers(), getConfigImpl(), registerHandlerFactory(), resetConfig(), unregisterHandlerFactory(), and updateConfig().

folly::Synchronized<LoggerNameMap> folly::LoggerDB::loggersByName_

private

A map of LogCategory objects by name.

Lookups can be performed using arbitrary StringPiece values that do not have to be in canonical form.

Definition at line 288 of file LoggerDB.h.

Referenced by cleanupHandlers(), flushAllHandlers(), getCategory(), getCategoryOrNull(), getConfigImpl(), resetConfig(), setLevel(), updateConfig(), xlogInit(), and xlogInitCategory().

std::atomic< LoggerDB::InternalWarningHandler > folly::LoggerDB::warningHandler_

staticprivate

Definition at line 298 of file LoggerDB.h.

Referenced by internalWarningImpl(), setInternalWarningHandler(), and xlogInitCategory().

---

The documentation for this class was generated from the following files:

• proxygen/folly/folly/logging/LoggerDB.h
• proxygen/folly/folly/logging/LoggerDB.cpp