LoggerDB.h

Go to the documentation of this file.

/*
 * Copyright 2017-present Facebook, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once

#include <folly/Conv.h>
#include <folly/CppAttributes.h>
#include <folly/Range.h>
#include <folly/Synchronized.h>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>

#include <folly/logging/LogName.h>

namespace folly {

class LogCategory;
class LogConfig;
class LogHandler;
class LogHandlerFactory;
enum class LogLevel : uint32_t;

class LoggerDB {
 public:
  static LoggerDB& get();

  ~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);

  enum TestConstructorArg { TESTING };

  explicit LoggerDB(TestConstructorArg);

  template <typename... Args>
  static void internalWarning(
      folly::StringPiece file,
      int lineNumber,
      Args&&... args) noexcept {
    internalWarningImpl(
        file, lineNumber, folly::to<std::string>(std::forward<Args>(args)...));
  }

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

  static void setInternalWarningHandler(InternalWarningHandler handler);

 private:
  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>>;
  struct HandlerInfo {
    HandlerFactoryMap factories;
    HandlerMap handlers;
  };

  // Forbidden copy constructor and assignment operator
  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);

  using NewHandlerMap =
      std::unordered_map<std::string, std::shared_ptr<LogHandler>>;
  using OldToNewHandlerMap = std::
      unordered_map<std::shared_ptr<LogHandler>, std::shared_ptr<LogHandler>>;
  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 void internalWarningImpl(
      folly::StringPiece filename,
      int lineNumber,
      std::string&& msg) noexcept;
  static void defaultInternalWarningImpl(
      folly::StringPiece filename,
      int lineNumber,
      std::string&& msg) noexcept;

  folly::Synchronized<LoggerNameMap> loggersByName_;

  folly::Synchronized<HandlerInfo> handlerInfo_;

  static std::atomic<InternalWarningHandler> warningHandler_;
};

void initializeLoggerDB(LoggerDB& db);

} // namespace folly