proxygen: folly::LogMessage Class Reference

#include <LogMessage.h>

Public Member Functions
	LogMessage (const LogCategory *category, LogLevel level, folly::StringPiece filename, unsigned int lineNumber, folly::StringPiece functionName, std::string &&msg)

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

	LogMessage (const LogCategory *category, LogLevel level, std::chrono::system_clock::time_point timestamp, folly::StringPiece filename, unsigned int lineNumber, folly::StringPiece functionName, std::string &&msg)

const LogCategory *	getCategory () const

LogLevel	getLevel () const

folly::StringPiece	getFileName () const

folly::StringPiece	getFileBaseName () const

unsigned int	getLineNumber () const

folly::StringPiece	getFunctionName () const

std::chrono::system_clock::time_point	getTimestamp () const

uint64_t	getThreadID () const

const std::string &	getMessage () const

const std::string &	getRawMessage () const

bool	containsNewlines () const

Private Member Functions
void	sanitizeMessage ()

Private Attributes
const LogCategory *const	category_ {nullptr}

LogLevel const	level_ {static_cast<LogLevel>(0)}

uint64_t const	threadID_ {0}

std::chrono::system_clock::time_point const	timestamp_

folly::StringPiece const	filename_

unsigned int const	lineNumber_ {0}

folly::StringPiece const	functionName_

bool	containsNewlines_ {false}

std::string const	rawMessage_

std::string	message_

Detailed Description

LogMessage represents a single message to be logged.

LogMessage objects are relatively temporary objects, that only exist for the time it takes to invoke all of the appropriate LogHandlers. These generally only live in the thread that logged the message, and are not modified once created. (That said, LogHandler implementations may copy and store LogMessage objects for later use if desired.)

Definition at line 38 of file LogMessage.h.

Constructor & Destructor Documentation

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

Definition at line 24 of file LogMessage.cpp.

References category_, filename_, functionName_, folly::getOSThreadID(), level_, lineNumber_, folly::gen::move, now(), rawMessage_, sanitizeMessage(), string, threadID_, and timestamp_.

Referenced by LogMessage().

     : category_{category},
       level_{level},
       threadID_{getOSThreadID()},
       timestamp_{system_clock::now()},
       filename_{filename},
       lineNumber_{lineNumber},
       functionName_{functionName},
       rawMessage_{std::move(msg)} {
   sanitizeMessage();
 }

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

inline

Definition at line 47 of file LogMessage.h.

References LogMessage(), and string.

       : LogMessage(
             category,
             level,
             filename,
             lineNumber,
             functionName,
             msg.str()) {}

folly::LogMessage::LogMessage	(	const LogCategory *	category,
		LogLevel	level,
		std::chrono::system_clock::time_point	timestamp,
		folly::StringPiece	filename,
		unsigned int	lineNumber,
		folly::StringPiece	functionName,
		std::string &&	msg
	)

Construct a LogMessage with an explicit timestamp. This is primarily intended for use in unit tests, so the tests can get deterministic behavior with regards to timestamps.

Member Function Documentation

bool folly::LogMessage::containsNewlines ( ) const

inline

Definition at line 117 of file LogMessage.h.

References containsNewlines_, and sanitizeMessage().

Referenced by folly::CustomLogFormatter::formatMessage(), and folly::GlogStyleFormatter::formatMessage().

                                 {
     return containsNewlines_;
   }

const LogCategory* folly::LogMessage::getCategory ( ) const

inline

Definition at line 76 of file LogMessage.h.

References category_.

                                          {
     return category_;
   }

StringPiece folly::LogMessage::getFileBaseName ( ) const

Definition at line 61 of file LogMessage.cpp.

References filename_, max, folly::Range< const char * >::npos, folly::Range< Iter >::rfind(), and folly::Range< Iter >::subpiece().

Referenced by folly::CustomLogFormatter::formatMessage(), folly::GlogStyleFormatter::formatMessage(), and getFileName().

                                               {
 #if _WIN32
   // Windows allows either backwards or forwards slash as path separator
   auto idx1 = filename_.rfind('\\');
   auto idx2 = filename_.rfind('/');
   StringPiece::size_type idx;
   if (idx1 == StringPiece::npos) {
     idx = idx2;
   } else if (idx2 == StringPiece::npos) {
     idx = idx1;
   } else {
     idx = std::max(idx1, idx2);
   }
 #else
   auto idx = filename_.rfind('/');
 #endif
   if (idx == StringPiece::npos) {
     return filename_;
   }
   return filename_.subpiece(idx + 1);
 }

folly::StringPiece folly::LogMessage::getFileName ( ) const

inline

Definition at line 84 of file LogMessage.h.

References filename_, and getFileBaseName().

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

                                        {
     return filename_;
   }

folly::StringPiece folly::LogMessage::getFunctionName ( ) const

inline

Definition at line 93 of file LogMessage.h.

References functionName_.

Referenced by folly::CustomLogFormatter::formatMessage().

                                            {
     return functionName_;
   }

LogLevel folly::LogMessage::getLevel ( ) const

inline

Definition at line 80 of file LogMessage.h.

References level_.

Referenced by folly::LogCategory::admitMessage(), folly::CustomLogFormatter::formatMessage(), folly::GlogStyleFormatter::formatMessage(), and folly::StandardLogHandler::handleMessage().

                             {
     return level_;
   }

unsigned int folly::LogMessage::getLineNumber ( ) const

inline

Definition at line 89 of file LogMessage.h.

References lineNumber_.

Referenced by folly::LogCategory::admitMessage(), folly::CustomLogFormatter::formatMessage(), and folly::GlogStyleFormatter::formatMessage().

                                      {
     return lineNumber_;
   }

const std::string& folly::LogMessage::getMessage ( ) const

inline

Definition at line 105 of file LogMessage.h.

References message_, and rawMessage_.

Referenced by folly::LogCategory::admitMessage(), folly::CustomLogFormatter::formatMessage(), and folly::GlogStyleFormatter::formatMessage().

                                       {
     // If no characters needed to be sanitized, message_ will be empty.
     if (message_.empty()) {
       return rawMessage_;
     }
     return message_;
   }

const std::string& folly::LogMessage::getRawMessage ( ) const

inline

Definition at line 113 of file LogMessage.h.

References rawMessage_.

                                          {
     return rawMessage_;
   }

uint64_t folly::LogMessage::getThreadID ( ) const

inline

Definition at line 101 of file LogMessage.h.

References threadID_.

Referenced by folly::CustomLogFormatter::formatMessage(), and folly::GlogStyleFormatter::formatMessage().

                                {
     return threadID_;
   }

std::chrono::system_clock::time_point folly::LogMessage::getTimestamp ( ) const

inline

Definition at line 97 of file LogMessage.h.

References timestamp_.

Referenced by folly::CustomLogFormatter::formatMessage(), and folly::GlogStyleFormatter::formatMessage().

                                                        {
     return timestamp_;
   }

void folly::LogMessage::sanitizeMessage ( )

private

Definition at line 83 of file LogMessage.cpp.

References c, containsNewlines_, folly::data(), message_, and rawMessage_.

Referenced by containsNewlines(), and LogMessage().

                                  {
   // Compute how long the sanitized string will be.
   size_t sanitizedLength = 0;
   for (const char c : rawMessage_) {
     if (c == '\\') {
       // Backslashes are escaped as two backslashes
       sanitizedLength += 2;
     } else if (static_cast<unsigned char>(c) < 0x20) {
       // Newlines and tabs are emitted directly with no escaping.
       // All other control characters are emitted as \xNN (4 characters)
       if (c == '\n') {
         sanitizedLength += 1;
         containsNewlines_ = true;
       } else if (c == '\t') {
         sanitizedLength += 1;
       } else {
         sanitizedLength += 4;
       }
     } else if (c == 0x7f) {
       // Bytes above the ASCII range are emitted as \xNN (4 characters)
       sanitizedLength += 4;
     } else {
       // This character will be emitted as-is, with no escaping.
       ++sanitizedLength;
     }
   }
 
   // If nothing is different, just use rawMessage_ directly,
   // and don't populate message_.
   if (sanitizedLength == rawMessage_.size()) {
     return;
   }
 
   message_.reserve(sanitizedLength);
   for (const char c : rawMessage_) {
     if (c == '\\') {
       message_.push_back('\\');
       message_.push_back('\\');
     } else if (static_cast<unsigned char>(c) < 0x20) {
       if (c == '\n' || c == '\t') {
         message_.push_back(c);
       } else {
         static constexpr StringPiece hexdigits{"0123456789abcdef"};
         std::array<char, 4> data{
             {'\\', 'x', hexdigits[(c >> 4) & 0xf], hexdigits[c & 0xf]}};
         message_.append(data.data(), data.size());
       }
     } else if (c == 0x7f) {
       constexpr std::array<char, 4> data{{'\\', 'x', '7', 'f'}};
       message_.append(data.data(), data.size());
     } else {
       message_.push_back(c);
     }
   }
 }

Member Data Documentation

const LogCategory* const folly::LogMessage::category_ {nullptr}

private

Definition at line 124 of file LogMessage.h.

Referenced by getCategory(), and LogMessage().

bool folly::LogMessage::containsNewlines_ {false}

private

containsNewlines_ will be true if the message contains internal newlines.

This allows log handlers that perform special handling of multi-line messages to easily detect if a message contains multiple lines or not.

Definition at line 150 of file LogMessage.h.

Referenced by containsNewlines(), and sanitizeMessage().

folly::StringPiece const folly::LogMessage::filename_

private

The name of the source file that generated this log message.

Definition at line 132 of file LogMessage.h.

Referenced by getFileBaseName(), getFileName(), and LogMessage().

folly::StringPiece const folly::LogMessage::functionName_

private

The name of the function that generated this log message.

Definition at line 142 of file LogMessage.h.

Referenced by getFunctionName(), and LogMessage().

LogLevel const folly::LogMessage::level_ {static_cast<LogLevel>(0)}

private

Definition at line 125 of file LogMessage.h.

Referenced by getLevel(), and LogMessage().

unsigned int const folly::LogMessage::lineNumber_ {0}

private

The line number in the source file that generated this log message.

Definition at line 137 of file LogMessage.h.

Referenced by getLineNumber(), and LogMessage().

std::string folly::LogMessage::message_

private

message_ contains a sanitized version of the log message.

nul bytes and unprintable characters have been escaped. This message may still contain newlines, however. LogHandler classes are responsible for deciding how they want to handle log messages with internal newlines.

Definition at line 168 of file LogMessage.h.

Referenced by getMessage(), and sanitizeMessage().

std::string const folly::LogMessage::rawMessage_

private

rawMessage_ contains the original message.

This may contain arbitrary binary data, including unprintable characters and nul bytes.

Definition at line 158 of file LogMessage.h.

Referenced by getMessage(), getRawMessage(), LogMessage(), and sanitizeMessage().