xlog.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/Likely.h>
#include <folly/Portability.h>
#include <folly/Range.h>
#include <folly/logging/LogStream.h>
#include <folly/logging/Logger.h>
#include <folly/logging/LoggerDB.h>
#include <folly/logging/RateLimiter.h>
#include <cstdlib>

/*
 * This file contains the XLOG() and XLOGF() macros.
 *
 * These macros make it easy to use the logging library without having to
 * manually pick log category names.  All XLOG() and XLOGF() statements in a
 * given file automatically use a LogCategory based on the current file name.
 *
 * For instance, in src/foo/bar.cpp, the default log category name will be
 * "src.foo.bar"
 *
 * If desired, the log category name used by XLOG() in a .cpp file may be
 * overridden using XLOG_SET_CATEGORY_NAME() macro.
 */

#define XLOG(level, ...)                   \
  XLOG_IMPL(                               \
      ::folly::LogLevel::level,            \
      ::folly::LogStreamProcessor::APPEND, \
      ##__VA_ARGS__)

#define XLOG_IF(level, cond, ...)          \
  XLOG_IF_IMPL(                            \
      ::folly::LogLevel::level,            \
      cond,                                \
      ::folly::LogStreamProcessor::APPEND, \
      ##__VA_ARGS__)

#define XLOGF(level, fmt, arg1, ...)       \
  XLOG_IMPL(                               \
      ::folly::LogLevel::level,            \
      ::folly::LogStreamProcessor::FORMAT, \
      fmt,                                 \
      arg1,                                \
      ##__VA_ARGS__)

#define XLOGF_IF(level, cond, fmt, arg1, ...) \
  XLOG_IF_IMPL(                               \
      ::folly::LogLevel::level,               \
      cond,                                   \
      ::folly::LogStreamProcessor::FORMAT,    \
      fmt,                                    \
      arg1,                                   \
      ##__VA_ARGS__)

#define XLOG_EVERY_MS(level, ms, ...)                                    \
  XLOG_IF(                                                               \
      level,                                                             \
      [] {                                                               \
        static ::folly::logging::IntervalRateLimiter                     \
            folly_detail_xlog_limiter(1, std::chrono::milliseconds(ms)); \
        return folly_detail_xlog_limiter.check();                        \
      }(),                                                               \
      ##__VA_ARGS__)

#define XLOG_EVERY_N(level, n, ...)                                            \
  XLOG_IF(                                                                     \
      level,                                                                   \
      [] {                                                                     \
        static std::atomic<size_t> folly_detail_xlog_count{0};                 \
        return FOLLY_UNLIKELY(                                                 \
            (folly_detail_xlog_count.fetch_add(1, std::memory_order_relaxed) % \
             (n)) == 0);                                                       \
      }(),                                                                     \
      ##__VA_ARGS__)

#define XLOG_N_PER_MS(level, count, ms, ...)                                   \
  XLOG_IF(                                                                     \
      level,                                                                   \
      [] {                                                                     \
        static ::folly::logging::IntervalRateLimiter                           \
            folly_detail_xlog_limiter((count), std::chrono::milliseconds(ms)); \
        return folly_detail_xlog_limiter.check();                              \
      }(),                                                                     \
      ##__VA_ARGS__)

#ifdef FOLLY_XLOG_STRIP_PREFIXES
#define XLOG_FILENAME \
  folly::xlogStripFilename(__FILE__, FOLLY_XLOG_STRIP_PREFIXES)
#else
#define XLOG_FILENAME __FILE__
#endif

#define XLOG_IMPL(level, type, ...) \
  XLOG_ACTUAL_IMPL(                 \
      level, true, ::folly::isLogLevelFatal(level), type, ##__VA_ARGS__)

#define XLOG_IF_IMPL(level, cond, type, ...) \
  XLOG_ACTUAL_IMPL(level, cond, false, type, ##__VA_ARGS__)

#define XLOG_ACTUAL_IMPL(level, cond, always_fatal, type, ...)             \
  (!XLOG_IS_ON_IMPL(level) || !(cond))                                     \
      ? ::folly::logDisabledHelper(::folly::bool_constant<always_fatal>{}) \
      : ::folly::LogStreamVoidify<::folly::isLogLevelFatal(level)>{} &     \
          ::folly::LogStreamProcessor(                                     \
              [] {                                                         \
                static ::folly::XlogCategoryInfo<XLOG_IS_IN_HEADER_FILE>   \
                    folly_detail_xlog_category;                            \
                return folly_detail_xlog_category.getInfo(                 \
                    &xlog_detail::xlogFileScopeInfo);                      \
              }(),                                                         \
              (level),                                                     \
              xlog_detail::getXlogCategoryName(XLOG_FILENAME, 0),          \
              xlog_detail::isXlogCategoryOverridden(0),                    \
              XLOG_FILENAME,                                               \
              __LINE__,                                                    \
              __func__,                                                    \
              (type),                                                      \
              ##__VA_ARGS__)                                               \
              .stream()

#define XLOG_IS_ON(level) XLOG_IS_ON_IMPL(::folly::LogLevel::level)

#define XLOG_IS_ON_IMPL(level)                              \
  ([] {                                                     \
    static ::folly::XlogLevelInfo<XLOG_IS_IN_HEADER_FILE>   \
        folly_detail_xlog_level;                            \
    return folly_detail_xlog_level.check(                   \
        (level),                                            \
        xlog_detail::getXlogCategoryName(XLOG_FILENAME, 0), \
        xlog_detail::isXlogCategoryOverridden(0),           \
        &xlog_detail::xlogFileScopeInfo);                   \
  }())

#define XLOG_GET_CATEGORY_NAME()                            \
  (xlog_detail::isXlogCategoryOverridden(0)                 \
       ? xlog_detail::getXlogCategoryName(XLOG_FILENAME, 0) \
       : ::folly::getXlogCategoryNameForFile(XLOG_FILENAME))

#define XLOG_GET_CATEGORY() \
  folly::LoggerDB::get().getCategory(XLOG_GET_CATEGORY_NAME())

#ifdef __INCLUDE_LEVEL__
#define XLOG_SET_CATEGORY_CHECK \
  static_assert(                \
      __INCLUDE_LEVEL__ == 0,   \
      "XLOG_SET_CATEGORY_NAME() should not be used in header files");
#else
#define XLOG_SET_CATEGORY_CHECK
#endif

#define XLOG_SET_CATEGORY_NAME(category)                   \
  namespace {                                              \
  namespace xlog_detail {                                  \
  XLOG_SET_CATEGORY_CHECK                                  \
  constexpr inline folly::StringPiece getXlogCategoryName( \
      folly::StringPiece,                                  \
      int) {                                               \
    return category;                                       \
  }                                                        \
  constexpr inline bool isXlogCategoryOverridden(int) {    \
    return true;                                           \
  }                                                        \
  }                                                        \
  }

#define XCHECK(cond, ...) \
  XLOG_IF(FATAL, UNLIKELY(!(cond)), "Check failed: " #cond " ", ##__VA_ARGS__)

#define XDCHECK(cond, ...) \
  (!::folly::kIsDebug) ? static_cast<void>(0) : XCHECK(cond, ##__VA_ARGS__)

#ifdef __INCLUDE_LEVEL__
#define XLOG_IS_IN_HEADER_FILE bool(__INCLUDE_LEVEL__ > 0)
#else
// Without __INCLUDE_LEVEL__ we canot tell if we are in a header file or not,
// and must pessimstically assume we are always in a header file.
#define XLOG_IS_IN_HEADER_FILE true
#endif

namespace folly {

class XlogFileScopeInfo {
 public:
#ifdef __INCLUDE_LEVEL__
  std::atomic<::folly::LogLevel> level;
  ::folly::LogCategory* category;
#endif
};

template <bool IsInHeaderFile>
class XlogLevelInfo {
 public:
  bool check(
      LogLevel levelToCheck,
      folly::StringPiece categoryName,
      bool isOverridden,
      XlogFileScopeInfo*) {
    // Do an initial relaxed check.  If this fails we know the category level
    // is initialized and the log admittance check failed.
    // Use LIKELY() to optimize for the case of disabled debug statements:
    // we disabled debug statements to be cheap.  If the log message is
    // enabled then this check will still be minimal perf overhead compared to
    // the overall cost of logging it.
    if (LIKELY(levelToCheck < level_.load(std::memory_order_relaxed))) {
      return false;
    }

    // If we are still here, then either:
    // - The log level check actually passed, or
    // - level_ has not been initialized yet, and we have to initialize it and
    //   then re-perform the check.
    //
    // Do this work in a separate helper method.  It is intentionally defined
    // in the xlog.cpp file to avoid inlining, to reduce the amount of code
    // emitted for each XLOG() statement.
    auto currentLevel = loadLevelFull(categoryName, isOverridden);
    return levelToCheck >= currentLevel;
  }

 private:
  LogLevel loadLevelFull(folly::StringPiece categoryName, bool isOverridden);

  // XlogLevelInfo objects are always defined with static storage.
  // This member will always be zero-initialized on program start.
  std::atomic<LogLevel> level_;
};

template <bool IsInHeaderFile>
class XlogCategoryInfo {
 public:
  bool isInitialized() const {
    return isInitialized_.load(std::memory_order_acquire);
  }

  LogCategory* init(folly::StringPiece categoryName, bool isOverridden);

  LogCategory* getCategory(XlogFileScopeInfo*) {
    return category_;
  }

  XlogCategoryInfo<IsInHeaderFile>* getInfo(XlogFileScopeInfo*) {
    return this;
  }

 private:
  // These variables will always be zero-initialized on program start.
  std::atomic<bool> isInitialized_;
  LogCategory* category_;
};

#ifdef __INCLUDE_LEVEL__

template <>
class XlogLevelInfo<false> {
 public:
  static bool check(
      LogLevel levelToCheck,
      folly::StringPiece categoryName,
      bool isOverridden,
      XlogFileScopeInfo* fileScopeInfo) {
    // As above in the non-specialized XlogFileScopeInfo code, do a simple
    // relaxed check first.
    if (LIKELY(
            levelToCheck <
            fileScopeInfo->level.load(::std::memory_order_relaxed))) {
      return false;
    }

    // If we are still here we the file-scope log level either needs to be
    // initalized, or the log level check legitimately passed.
    auto currentLevel =
        loadLevelFull(categoryName, isOverridden, fileScopeInfo);
    return levelToCheck >= currentLevel;
  }

 private:
  static LogLevel loadLevelFull(
      folly::StringPiece categoryName,
      bool isOverridden,
      XlogFileScopeInfo* fileScopeInfo);
};

template <>
class XlogCategoryInfo<false> {
 public:
  XlogFileScopeInfo* getInfo(XlogFileScopeInfo* fileScopeInfo) {
    return fileScopeInfo;
  }
};
#endif

folly::StringPiece getXlogCategoryNameForFile(folly::StringPiece filename);

constexpr bool xlogIsDirSeparator(char c) {
  return c == '/' || (kIsWindows && c == '\\');
}

namespace detail {
constexpr const char* xlogStripFilenameRecursive(
    const char* filename,
    const char* prefixes,
    size_t prefixIdx,
    size_t filenameIdx,
    bool match);
constexpr const char* xlogStripFilenameMatchFound(
    const char* filename,
    const char* prefixes,
    size_t prefixIdx,
    size_t filenameIdx) {
  return (filename[filenameIdx] == '\0')
      ? xlogStripFilenameRecursive(filename, prefixes, prefixIdx + 1, 0, true)
      : (xlogIsDirSeparator(filename[filenameIdx])
             ? xlogStripFilenameMatchFound(
                   filename, prefixes, prefixIdx, filenameIdx + 1)
             : (filename + filenameIdx));
}
constexpr const char* xlogStripFilenameRecursive(
    const char* filename,
    const char* prefixes,
    size_t prefixIdx,
    size_t filenameIdx,
    bool match) {
  // This would be much easier to understand if written as a while loop.
  // However, in order to maintain compatibility with pre-C++14 compilers we
  // have implemented it recursively to adhere to C++11 restrictions for
  // constexpr functions.
  return (prefixes[prefixIdx] == ':' || prefixes[prefixIdx] == '\0')
      ? ((match && filenameIdx > 0 &&
          (xlogIsDirSeparator(prefixes[filenameIdx - 1]) ||
           xlogIsDirSeparator(filename[filenameIdx])))
             ? (xlogStripFilenameMatchFound(
                   filename, prefixes, prefixIdx, filenameIdx))
             : ((prefixes[prefixIdx] == '\0')
                    ? filename
                    : xlogStripFilenameRecursive(
                          filename, prefixes, prefixIdx + 1, 0, true)))
      : ((match && (prefixes[prefixIdx] == filename[filenameIdx]))
             ? xlogStripFilenameRecursive(
                   filename, prefixes, prefixIdx + 1, filenameIdx + 1, true)
             : xlogStripFilenameRecursive(
                   filename, prefixes, prefixIdx + 1, 0, false));
}
} // namespace detail

constexpr const char* xlogStripFilename(
    const char* filename,
    const char* prefixes) {
  return detail::xlogStripFilenameRecursive(filename, prefixes, 0, 0, true);
}
} // namespace folly

/*
 * We intentionally use an unnamed namespace inside a header file here.
 *
 * We want each .cpp file that uses xlog.h to get its own separate
 * implementation of the following functions and variables.
 */
namespace {
namespace xlog_detail {
template <typename T>
constexpr inline folly::StringPiece getXlogCategoryName(
    folly::StringPiece filename,
    T) {
  return filename;
}

template <typename T>
constexpr inline bool isXlogCategoryOverridden(T) {
  return false;
}

::folly::XlogFileScopeInfo xlogFileScopeInfo;
} // namespace xlog_detail
} // namespace