Logger.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/Format.h>
#include <folly/logging/LogCategory.h>
#include <folly/logging/LogLevel.h>
#include <folly/logging/LogStream.h>
#include <folly/logging/LogStreamProcessor.h>

#define FB_LOG(logger, level, ...)         \
  FB_LOG_IMPL(                             \
      logger,                              \
      ::folly::LogLevel::level,            \
      ::folly::LogStreamProcessor::APPEND, \
      ##__VA_ARGS__)

#define FB_LOGF(logger, level, fmt, arg1, ...) \
  FB_LOG_IMPL(                                 \
      logger,                                  \
      ::folly::LogLevel::level,                \
      ::folly::LogStreamProcessor::FORMAT,     \
      fmt,                                     \
      arg1,                                    \
      ##__VA_ARGS__)

#define FB_LOG_RAW(logger, level, filename, linenumber, functionName, ...) \
  FB_LOG_RAW_IMPL(                                                         \
      logger,                                                              \
      level,                                                               \
      filename,                                                            \
      linenumber,                                                          \
      functionName,                                                        \
      ::folly::LogStreamProcessor::APPEND,                                 \
      ##__VA_ARGS__)

#define FB_LOGF_RAW(                                                   \
    logger, level, filename, linenumber, functionName, fmt, arg1, ...) \
  FB_LOG_RAW_IMPL(                                                     \
      logger,                                                          \
      level,                                                           \
      filename,                                                        \
      linenumber,                                                      \
      functionName,                                                    \
      ::folly::LogStreamProcessor::FORMAT,                             \
      fmt,                                                             \
      arg1,                                                            \
      ##__VA_ARGS__)

#define FB_LOG_IMPL(logger, level, type, ...)                          \
  (!(logger).getCategory()->logCheck(level))                           \
      ? ::folly::logDisabledHelper(                                    \
            ::folly::bool_constant<::folly::isLogLevelFatal(level)>{}) \
      : ::folly::LogStreamVoidify<::folly::isLogLevelFatal(level)>{} & \
          ::folly::LogStreamProcessor{(logger).getCategory(),          \
                                      (level),                         \
                                      __FILE__,                        \
                                      __LINE__,                        \
                                      __func__,                        \
                                      (type),                          \
                                      ##__VA_ARGS__}                   \
              .stream()

#define FB_LOG_RAW_IMPL(                                      \
    logger, level, filename, line, functionName, type, ...)   \
  (!(logger).getCategory()->logCheck(level))                  \
      ? static_cast<void>(0)                                  \
      : ::folly::LogStreamVoidify<false>{} &                  \
          ::folly::LogStreamProcessor{(logger).getCategory(), \
                                      (level),                \
                                      (filename),             \
                                      (line),                 \
                                      (functionName),         \
                                      (type),                 \
                                      ##__VA_ARGS__}          \
              .stream()

namespace folly {

class LoggerDB;
class LogMessage;

class Logger {
 public:
  explicit Logger(folly::StringPiece name);

  explicit Logger(LogCategory* cat);

  Logger(LoggerDB* db, folly::StringPiece name);

  LogCategory* getCategory() const {
    return category_;
  }

 private:
  LogCategory* const category_{nullptr};
};
} // namespace folly