proxygen: folly::LogStreamProcessor Class Reference

#include <LogStreamProcessor.h>

Public Types
enum	AppendType { APPEND }

enum	FormatType { FORMAT }

Public Member Functions
	LogStreamProcessor (const LogCategory *category, LogLevel level, folly::StringPiece filename, unsigned int lineNumber, folly::StringPiece functionName, AppendType) noexcept

template<typename... Args>
	LogStreamProcessor (const LogCategory *category, LogLevel level, folly::StringPiece filename, unsigned int lineNumber, folly::StringPiece functionName, AppendType, Args &&...args) noexcept

template<typename... Args>
	LogStreamProcessor (const LogCategory *category, LogLevel level, folly::StringPiece filename, unsigned int lineNumber, folly::StringPiece functionName, FormatType, folly::StringPiece fmt, Args &&...args) noexcept

	LogStreamProcessor (XlogCategoryInfo< true > *categoryInfo, LogLevel level, folly::StringPiece categoryName, bool isCategoryNameOverridden, folly::StringPiece filename, unsigned int lineNumber, folly::StringPiece functionName, AppendType) noexcept

template<typename... Args>
	LogStreamProcessor (XlogCategoryInfo< true > *categoryInfo, LogLevel level, folly::StringPiece categoryName, bool isCategoryNameOverridden, folly::StringPiece filename, unsigned int lineNumber, folly::StringPiece functionName, AppendType, Args &&...args) noexcept

template<typename... Args>
	LogStreamProcessor (XlogCategoryInfo< true > *categoryInfo, LogLevel level, folly::StringPiece categoryName, bool isCategoryNameOverridden, folly::StringPiece filename, unsigned int lineNumber, folly::StringPiece functionName, FormatType, folly::StringPiece fmt, Args &&...args) noexcept

	~LogStreamProcessor () noexcept

void	operator& (std::ostream &stream) noexcept

void	operator& (LogStream &&stream) noexcept

std::ostream &	stream () noexcept

void	logNow () noexcept

Private Types
enum	InternalType { INTERNAL }

Private Member Functions
	LogStreamProcessor (const LogCategory *category, LogLevel level, folly::StringPiece filename, unsigned int lineNumber, folly::StringPiece functionName, InternalType, std::string &&msg) noexcept

	LogStreamProcessor (XlogCategoryInfo< true > *categoryInfo, LogLevel level, folly::StringPiece categoryName, bool isCategoryNameOverridden, folly::StringPiece filename, unsigned int lineNumber, folly::StringPiece functionName, InternalType, std::string &&msg) noexcept

	LogStreamProcessor (XlogFileScopeInfo *fileScopeInfo, LogLevel level, folly::StringPiece filename, unsigned int lineNumber, folly::StringPiece functionName, InternalType, std::string &&msg) noexcept

std::string	extractMessageString (LogStream &stream) noexcept

template<typename... Args>
FOLLY_NOINLINE std::string	createLogString (Args &&...args) noexcept

template<typename... Args>
FOLLY_NOINLINE std::string	formatLogString (folly::StringPiece fmt, const Args &...args) noexcept

template<typename Arg1 , typename... Args>
void	fallbackFormat (std::string *str, const Arg1 &arg1, const Args &...remainder)

template<typename Arg >
void	fallbackFormat (std::string *str, const Arg &arg)

Private Attributes
const LogCategory *const	category_

LogLevel const	level_

folly::StringPiece	filename_

unsigned int	lineNumber_

folly::StringPiece	functionName_

std::string	message_

LogStream	stream_

Detailed Description

LogStreamProcessor receives a LogStream and logs it.

This class is primarily intended to be used through the FB_LOG*() macros. Its API is designed to support these macros, and is not designed for other use.

The operator&() method is used to trigger the logging. This operator is used because it has lower precedence than <<, but higher precedence than the ? ternary operator, allowing it to bind with the correct precedence in the log macro implementations.

Definition at line 89 of file LogStreamProcessor.h.

Member Enumeration Documentation

enum folly::LogStreamProcessor::AppendType

Enumerator
APPEND

Definition at line 91 of file LogStreamProcessor.h.

91 { APPEND };

folly::LogStreamProcessor::APPEND

Definition: LogStreamProcessor.h:91

enum folly::LogStreamProcessor::FormatType

Enumerator
FORMAT

Definition at line 92 of file LogStreamProcessor.h.

92 { FORMAT };

folly::LogStreamProcessor::FORMAT

Definition: LogStreamProcessor.h:92

enum folly::LogStreamProcessor::InternalType

private

Enumerator
INTERNAL

Definition at line 326 of file LogStreamProcessor.h.

326 { INTERNAL };

folly::LogStreamProcessor::INTERNAL

Definition: LogStreamProcessor.h:326

Constructor & Destructor Documentation

folly::LogStreamProcessor::LogStreamProcessor	(	const LogCategory *	category,
		LogLevel	level,
		folly::StringPiece	filename,
		unsigned int	lineNumber,
		folly::StringPiece	functionName,
		AppendType
	)

noexcept

LogStreamProcessor constructor for use with a LOG() macro with no extra arguments.

Note that the filename argument is not copied. The caller should ensure that it points to storage that will remain valid for the lifetime of the LogStreamProcessor. (This is always the case for the FILE preprocessor macro.)

Definition at line 23 of file LogStreamProcessor.cpp.

Referenced by LogStreamProcessor().

     : LogStreamProcessor(
           category,
           level,
           filename,
           lineNumber,
           functionName,
           INTERNAL,
           std::string()) {}

template<typename... Args>

folly::LogStreamProcessor::LogStreamProcessor	(	const LogCategory *	category,
		LogLevel	level,
		folly::StringPiece	filename,
		unsigned int	lineNumber,
		folly::StringPiece	functionName,
		AppendType	,
		Args &&...	args
	)

inlinenoexcept

LogStreamProcessor constructor for use with a LOG() macro with arguments to be concatenated with folly::to<std::string>()

Definition at line 121 of file LogStreamProcessor.h.

References testing::Args().

       : LogStreamProcessor(
             category,
             level,
             filename,
             lineNumber,
             functionName,
             INTERNAL,
             createLogString(std::forward<Args>(args)...)) {}

template<typename... Args>

folly::LogStreamProcessor::LogStreamProcessor	(	const LogCategory *	category,
		LogLevel	level,
		folly::StringPiece	filename,
		unsigned int	lineNumber,
		folly::StringPiece	functionName,
		FormatType	,
		folly::StringPiece	fmt,
		Args &&...	args
	)

inlinenoexcept

LogStreamProcessor constructor for use with a LOG() macro with arguments to be concatenated with folly::to<std::string>()

Definition at line 148 of file LogStreamProcessor.h.

References testing::Args(), and folly::pushmi::__adl::noexcept().

       : LogStreamProcessor(
             category,
             level,
             filename,
             lineNumber,
             functionName,
             INTERNAL,
             formatLogString(fmt, std::forward<Args>(args)...)) {}

folly::LogStreamProcessor::LogStreamProcessor	(	XlogCategoryInfo< true > *	categoryInfo,
		LogLevel	level,
		folly::StringPiece	categoryName,
		bool	isCategoryNameOverridden,
		folly::StringPiece	filename,
		unsigned int	lineNumber,
		folly::StringPiece	functionName,
		AppendType
	)

noexcept

Definition at line 39 of file LogStreamProcessor.cpp.

     : LogStreamProcessor(
           categoryInfo,
           level,
           categoryName,
           isCategoryNameOverridden,
           filename,
           lineNumber,
           functionName,
           INTERNAL,
           std::string()) {}

template<typename... Args>

folly::LogStreamProcessor::LogStreamProcessor	(	XlogCategoryInfo< true > *	categoryInfo,
		LogLevel	level,
		folly::StringPiece	categoryName,
		bool	isCategoryNameOverridden,
		folly::StringPiece	filename,
		unsigned int	lineNumber,
		folly::StringPiece	functionName,
		AppendType	,
		Args &&...	args
	)

inlinenoexcept

Definition at line 185 of file LogStreamProcessor.h.

References testing::Args().

       : LogStreamProcessor(
             categoryInfo,
             level,
             categoryName,
             isCategoryNameOverridden,
             filename,
             lineNumber,
             functionName,
             INTERNAL,
             createLogString(std::forward<Args>(args)...)) {}

template<typename... Args>

folly::LogStreamProcessor::LogStreamProcessor	(	XlogCategoryInfo< true > *	categoryInfo,
		LogLevel	level,
		folly::StringPiece	categoryName,
		bool	isCategoryNameOverridden,
		folly::StringPiece	filename,
		unsigned int	lineNumber,
		folly::StringPiece	functionName,
		FormatType	,
		folly::StringPiece	fmt,
		Args &&...	args
	)

inlinenoexcept

Definition at line 206 of file LogStreamProcessor.h.

References testing::Args(), folly::pushmi::__adl::noexcept(), and folly::operator&().

       : LogStreamProcessor(
             categoryInfo,
             level,
             categoryName,
             isCategoryNameOverridden,
             filename,
             lineNumber,
             functionName,
             INTERNAL,
             formatLogString(fmt, std::forward<Args>(args)...)) {}

folly::LogStreamProcessor::~LogStreamProcessor ( )

noexcept

Definition at line 177 of file LogStreamProcessor.cpp.

References logNow().

                                                  {
   // The LogStreamProcessor destructor is responsible for logging the message.
   // Doing this in the destructor avoids an separate function call to log the
   // message being emitted inline at every log statement site.
   logNow();
 }

folly::LogStreamProcessor::LogStreamProcessor	(	const LogCategory *	category,
		LogLevel	level,
		folly::StringPiece	filename,
		unsigned int	lineNumber,
		folly::StringPiece	functionName,
		InternalType	,
		std::string &&	msg
	)

privatenoexcept

Definition at line 59 of file LogStreamProcessor.cpp.

References filename_, functionName_, folly::XlogCategoryInfo< IsInHeaderFile >::getCategory(), folly::XlogCategoryInfo< IsInHeaderFile >::init(), folly::XlogCategoryInfo< IsInHeaderFile >::isInitialized(), level_, lineNumber_, message_, folly::gen::move, and stream_.

     : category_{category},
       level_{level},
       filename_{filename},
       lineNumber_{lineNumber},
       functionName_{functionName},
       message_{std::move(msg)},
       stream_{this} {}

folly::LogStreamProcessor::LogStreamProcessor	(	XlogCategoryInfo< true > *	categoryInfo,
		LogLevel	level,
		folly::StringPiece	categoryName,
		bool	isCategoryNameOverridden,
		folly::StringPiece	filename,
		unsigned int	lineNumber,
		folly::StringPiece	functionName,
		InternalType	,
		std::string &&	msg
	)

privatenoexcept

Construct a LogStreamProcessor from an XlogCategoryInfo.

We intentionally define this in LogStreamProcessor.cpp instead of LogStreamProcessor.h to avoid having it inlined at every XLOG() call site, to reduce the emitted code size.

Definition at line 94 of file LogStreamProcessor.cpp.

References category_, filename_, functionName_, INTERNAL, level_, lineNumber_, LogStreamProcessor(), message_, folly::gen::move, folly::pushmi::__adl::noexcept(), stream_, and string.

     : category_{getXlogCategory(
           categoryInfo,
           categoryName,
           isCategoryNameOverridden)},
       level_{level},
       filename_{filename},
       lineNumber_{lineNumber},
       functionName_{functionName},
       message_{std::move(msg)},
       stream_{this} {}

folly::LogStreamProcessor::LogStreamProcessor	(	XlogFileScopeInfo *	fileScopeInfo,
		LogLevel	level,
		folly::StringPiece	filename,
		unsigned int	lineNumber,
		folly::StringPiece	functionName,
		InternalType	,
		std::string &&	msg
	)

privatenoexcept

Member Function Documentation

template<typename... Args>

FOLLY_NOINLINE std::string folly::LogStreamProcessor::createLogString ( Args &&... args )

inlineprivatenoexcept

Construct a log message string using folly::to<std::string>()

This function attempts to avoid throwing exceptions. If an error occurs during formatting, a message including the error details is returned instead. This is done to help ensure that log statements do not generate exceptions, but instead just log an error string when something goes wrong.

Definition at line 365 of file LogStreamProcessor.h.

References testing::Args().

                                                                     {
     try {
       return folly::to<std::string>(std::forward<Args>(args)...);
     } catch (const std::exception& ex) {
       // This most likely means there was some error converting the arguments
       // to strings.  Handle the exception here, rather than letting it
       // propagate up, since callers generally do not expect log statements to
       // throw.
       //
       // Just log an error message letting indicating that something went wrong
       // formatting the log message.
       return folly::to<std::string>(
           "error constructing log message: ", ex.what());
     }
   }

std::string folly::LogStreamProcessor::extractMessageString ( LogStream & stream )

privatenoexcept

Definition at line 201 of file LogStreamProcessor.cpp.

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

Referenced by logNow().

                                 {
   if (stream.empty()) {
     return std::move(message_);
   }
 
   if (message_.empty()) {
     return stream.extractString();
   }
   message_.append(stream.extractString());
   return std::move(message_);
 }

template<typename Arg1 , typename... Args>

void folly::LogStreamProcessor::fallbackFormat	(	std::string *	str,
		const Arg1 &	arg1,
		const Args &...	remainder
	)

inlineprivate

Helper function generate a fallback version of the arguments in case folly::sformat() throws an exception.

This attempts to convert each argument to a string using a similar mechanism to folly::to<std::string>(), if supported.

Definition at line 423 of file LogStreamProcessor.h.

References folly::detail::fallbackFormatOneArg().

                                                                              {
     detail::fallbackFormatOneArg(str, &arg1, 0);
     str->append(", ");
     fallbackFormat(str, remainder...);
   }

template<typename Arg >

void folly::LogStreamProcessor::fallbackFormat	(	std::string *	str,
		const Arg &	arg
	)

inlineprivate

Definition at line 430 of file LogStreamProcessor.h.

References folly::detail::fallbackFormatOneArg().

                                                       {
     detail::fallbackFormatOneArg(str, &arg, 0);
   }

template<typename... Args>

FOLLY_NOINLINE std::string folly::LogStreamProcessor::formatLogString	(	folly::StringPiece	fmt,
		const Args &...	args
	)

inlineprivatenoexcept

Construct a log message string using folly::sformat()

Definition at line 390 of file LogStreamProcessor.h.

References testing::Args(), folly::Range< Iter >::data(), folly::sformat(), folly::Range< Iter >::size(), and string.

                                     {
     try {
       return folly::sformat(fmt, args...);
     } catch (const std::exception& ex) {
       // This most likely means that the caller had a bug in their format
       // string/arguments.  Handle the exception here, rather than letting it
       // propagate up, since callers generally do not expect log statements to
       // throw.
       //
       // Log the format string and as much of the arguments as we can convert,
       // to aid debugging.
       std::string result;
       result.append("error formatting log message: ");
       result.append(ex.what());
       result.append("; format string: \"");
       result.append(fmt.data(), fmt.size());
       result.append("\", arguments: ");
       fallbackFormat(&result, args...);
       return result;
     }
   }

void folly::LogStreamProcessor::logNow ( )

noexcept

Definition at line 184 of file LogStreamProcessor.cpp.

References folly::LogCategory::admitMessage(), category_, extractMessageString(), filename_, functionName_, level_, lineNumber_, and stream_.

Referenced by folly::LogStreamVoidify< true >::operator&(), and ~LogStreamProcessor().

                                          {
   // Note that admitMessage() is not noexcept and theoretically may throw.
   // However, the only exception that should be possible is std::bad_alloc if
   // we fail to allocate memory.  We intentionally let our noexcept specifier
   // crash in that case, since the program likely won't be able to continue
   // anyway.
   //
   // Any other error here is unexpected and we also want to fail hard
   // in that situation too.
   category_->admitMessage(LogMessage{category_,
                                      level_,
                                      filename_,
                                      lineNumber_,
                                      functionName_,
                                      extractMessageString(stream_)});
 }

void folly::LogStreamProcessor::operator& ( std::ostream & stream )

noexcept

This version of operator&() is typically used when the user specifies log arguments using the << stream operator. The operator<<() generally returns a std::ostream&

void folly::LogStreamProcessor::operator& ( LogStream && stream )

noexcept

This version of operator&() is used when no extra arguments are specified with the << operator. In this case the & operator is applied directly to the temporary LogStream object.

std::ostream& folly::LogStreamProcessor::stream ( )

inlinenoexcept

Definition at line 319 of file LogStreamProcessor.h.

References folly::pushmi::__adl::noexcept().

Referenced by folly::LogStreamVoidify< true >::operator&().

                                 {
     return stream_;
   }

Member Data Documentation

const LogCategory* const folly::LogStreamProcessor::category_

private

Definition at line 434 of file LogStreamProcessor.h.

Referenced by logNow(), and LogStreamProcessor().

folly::StringPiece folly::LogStreamProcessor::filename_

private

Definition at line 436 of file LogStreamProcessor.h.

Referenced by logNow(), and LogStreamProcessor().

folly::StringPiece folly::LogStreamProcessor::functionName_

private

Definition at line 438 of file LogStreamProcessor.h.

Referenced by logNow(), and LogStreamProcessor().

LogLevel const folly::LogStreamProcessor::level_

private

Definition at line 435 of file LogStreamProcessor.h.

Referenced by logNow(), and LogStreamProcessor().

unsigned int folly::LogStreamProcessor::lineNumber_

private

Definition at line 437 of file LogStreamProcessor.h.

Referenced by logNow(), and LogStreamProcessor().

std::string folly::LogStreamProcessor::message_

private

Definition at line 439 of file LogStreamProcessor.h.

Referenced by extractMessageString(), and LogStreamProcessor().

LogStream folly::LogStreamProcessor::stream_

private

Definition at line 440 of file LogStreamProcessor.h.

Referenced by logNow(), and LogStreamProcessor().

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

proxygen/folly/folly/logging/LogStreamProcessor.h
proxygen/folly/folly/logging/LogStreamProcessor.cpp

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation