proxygen: folly::CustomLogFormatter Class Reference

#include <CustomLogFormatter.h>

Inheritance diagram for folly::CustomLogFormatter:

Public Member Functions
	CustomLogFormatter (StringPiece format, bool colored)

std::string	formatMessage (const LogMessage &message, const LogCategory *handlerCategory) override

Public Member Functions inherited from folly::LogFormatter
virtual	~LogFormatter ()

Private Member Functions
void	parseFormatString (StringPiece format)

Private Attributes
std::string	logFormat_

std::string	singleLineLogFormat_

std::size_t	staticEstimatedWidth_ {0}

std::size_t	fileNameCount_ {0}

std::size_t	functionNameCount_ {0}

const bool	colored_

Detailed Description

A LogFormatter implementation that produces messages in a format specified using a config.

The glog message format is:

{L}{m:02d}{D:02d} {H:2d}:{M:02d}:{S:02d}.{USECS:06d} {THREAD:5d} {FILE}:{LINE}]

L: A 1-character code describing the log level (e.g., E, W, I, V) m: month D: day H: hour, 24-hour format M: minute S: second USECS: microseconds THREAD: Thread ID FILE: Filename (just the last component) FUN: The function that logged the message LINE: Line number

TODO: enable support for the following 2:

THREADNAME: the thread name.
THREADCTX: thread-local log context data, if it has been set. (This is a Facebook-specific modification)

Definition at line 50 of file CustomLogFormatter.h.

Constructor & Destructor Documentation

folly::CustomLogFormatter::CustomLogFormatter	(	StringPiece	format,
		bool	colored
	)

explicit

Definition at line 104 of file CustomLogFormatter.cpp.

References parseFormatString().

     : colored_(colored) {
   parseFormatString(format);
 }

Member Function Documentation

std::string folly::CustomLogFormatter::formatMessage	(	const LogMessage &	message,
		const LogCategory *	handlerCategory
	)

overridevirtual

Serialze a LogMessage object.

Parameters

message	The LogMessage object to serialze.
handlerCategory	The LogCategory that is currently handling this message. Note that this is likely different from the LogCategory where the message was originally logged, which can be accessed as message->getCategory()

Implements folly::LogFormatter.

Definition at line 231 of file CustomLogFormatter.cpp.

                           {
   // Get the local time info
   struct tm ltime;
   auto timeSinceEpoch = message.getTimestamp().time_since_epoch();
   auto epochSeconds =
       std::chrono::duration_cast<std::chrono::seconds>(timeSinceEpoch);
   std::chrono::microseconds usecs =
       std::chrono::duration_cast<std::chrono::microseconds>(timeSinceEpoch) -
       epochSeconds;
   time_t unixTimestamp = epochSeconds.count();
   if (!localtime_r(&unixTimestamp, &ltime)) {
     memset(&ltime, 0, sizeof(ltime));
   }
 
   auto basename = message.getFileBaseName();
 
   // Most common logs will be single line logs and so we can format the entire
   // log string including the message at once.
   if (!message.containsNewlines()) {
     return folly::sformat(
         singleLineLogFormat_,
         getGlogLevelName(message.getLevel())[0],
         ltime.tm_mon + 1,
         ltime.tm_mday,
         ltime.tm_hour,
         ltime.tm_min,
         ltime.tm_sec,
         usecs.count(),
         message.getThreadID(),
         basename,
         message.getFunctionName(),
         message.getLineNumber(),
         // NOTE: THE FOLLOWING ARGUMENTS ALWAYS NEED TO BE THE LAST 3:
         message.getMessage(),
         // If colored logs are enabled, the singleLineLogFormat_ will contain
         // placeholders for the color and the reset sequences. If not, then
         // the following params will just be ignored by the folly::sformat().
         getColorSequence(message.getLevel()),
         getResetSequence(message.getLevel()));
   }
   // If the message contains multiple lines, ensure that the log header is
   // prepended before each message line.
   else {
     const auto headerFormatter = folly::format(
         logFormat_,
         getGlogLevelName(message.getLevel())[0],
         ltime.tm_mon + 1,
         ltime.tm_mday,
         ltime.tm_hour,
         ltime.tm_min,
         ltime.tm_sec,
         usecs.count(),
         message.getThreadID(),
         basename,
         message.getFunctionName(),
         message.getLineNumber());
 
     // Estimate header length. If this still isn't long enough the string will
     // grow as necessary, so the code will still be correct, but just slightly
     // less efficient than if we had allocated a large enough buffer the first
     // time around.
     size_t headerLengthGuess = staticEstimatedWidth_ +
         (fileNameCount_ * basename.size()) +
         (functionNameCount_ * message.getFunctionName().size());
 
     // Format the data into a buffer.
     std::string buffer;
     // If colored logging is supported, then process the color based on
     // the level of the message.
     if (colored_) {
       buffer.append(getColorSequence(message.getLevel()).toString());
     }
     StringPiece msgData{message.getMessage()};
 
     // Make a guess at how many lines will be in the message, just to make an
     // initial buffer allocation.  If the guess is too small then the string
     // will reallocate and grow as necessary, it will just be slightly less
     // efficient than if we had guessed enough space.
     size_t numLinesGuess = 4;
     buffer.reserve((headerLengthGuess * numLinesGuess) + msgData.size());
 
     size_t idx = 0;
     while (true) {
       auto end = msgData.find('\n', idx);
       if (end == StringPiece::npos) {
         end = msgData.size();
       }
 
       auto line = msgData.subpiece(idx, end - idx);
       headerFormatter.appendTo(buffer);
       buffer.append(line.data(), line.size());
       buffer.push_back('\n');
 
       if (end == msgData.size()) {
         break;
       }
       idx = end + 1;
     }
     // If colored logging is supported and the current message is a color other
     // than the default, then RESET colors after printing message.
     if (colored_) {
       buffer.append(getResetSequence(message.getLevel()).toString());
     }
     return buffer;
   }
 }

void folly::CustomLogFormatter::parseFormatString ( StringPiece format )

private

Definition at line 109 of file CustomLogFormatter.cpp.

References a, b, folly::Range< Iter >::begin(), colored_, folly::Range< Iter >::end(), fileNameCount_, functionNameCount_, proxygen::HPACK::LITERAL, logFormat_, gmock_output_test::output, singleLineLogFormat_, folly::Range< Iter >::size(), staticEstimatedWidth_, string, and UNLIKELY.

Referenced by CustomLogFormatter().

                                                             {
   std::size_t estimatedWidth = 0;
   functionNameCount_ = 0;
   fileNameCount_ = 0;
   // Replace all format keys to numbers to improve performance and to use
   // varying value types (which is not possible using folly::vformat()).
   std::string output;
   output.reserve(input.size());
   const char* varNameStart = nullptr;
 
   enum StateEnum {
     LITERAL,
     FMT_NAME,
     FMT_MODIFIERS,
   } state = LITERAL;
 
   for (const char* p = input.begin(); p < input.end(); ++p) {
     switch (state) {
       case LITERAL:
         output.append(p, 1);
         // In case of `{{` or `}}`, copy it as it is and only increment the
         // estimatedWidth once as it will result to a single character in
         // output.
         if ((p + 1) != input.end() /* ensure not last character */ &&
             (0 == memcmp(p, "}}", 2) || 0 == memcmp(p, "{{", 2))) {
           output.append(p + 1, 1);
           estimatedWidth++;
           p++;
         }
         // If we see a single open curly brace, it denotes a start of a format
         // name and so we change the state to FMT_NAME and do not increment
         // estimatedWidth as it won't be in the output.
         else if (*p == '{') {
           varNameStart = p + 1;
           state = FMT_NAME;
         }
         // In case it is just a regular literal, just increment estimatedWidth
         // by one and move on to the next character.
         else {
           estimatedWidth++;
         }
         break;
       // In case we have started processing a format name/key
       case FMT_NAME:
         // Unless it is the end of the format name/key, do nothing and scan over
         // the name/key. When it is the end of the format name/key, look up
         // the argIndex for it and replace the name/key with that index.
         if (*p == ':' || *p == '}') {
           StringPiece varName(varNameStart, p);
           auto item = std::lower_bound(
               formatKeys.begin(),
               formatKeys.end(),
               varName,
               [](const auto& a, const auto& b) { return a.key < b; });
 
           if (UNLIKELY(item == formatKeys.end() || item->key != varName)) {
             throw std::runtime_error(folly::to<std::string>(
                 "unknown format argument \"", varName, "\""));
           }
           output.append(folly::to<std::string>(item->argIndex));
           output.append(p, 1);
 
           // Based on the format key, increment estimatedWidth with the
           // estimate of how many characters long the value of the format key
           // will be. If it is a FILE or a FUN, the width will be variable
           // depending on the values of those fields.
           estimatedWidth += item->width;
           if (item->key == "FILE") {
             fileNameCount_++;
           } else if (item->key == "FUN") {
             functionNameCount_++;
           }
 
           // Figure out if there are modifiers that follow the key or if we
           // continue processing literals.
           if (*p == ':') {
             state = FMT_MODIFIERS;
           } else {
             state = LITERAL;
           }
         }
         break;
       // In case we have started processing a format modifier (after :)
       case FMT_MODIFIERS:
         // Modifiers are just copied as is and are not considered to determine
         // the estimatedWidth.
         output.append(p, 1);
         if (*p == '}') {
           state = LITERAL;
         }
         break;
     }
   }
   if (state != LITERAL) {
     throw std::runtime_error("unterminated format string");
   }
   // Append a single space after the header format if header is not empty.
   if (!output.empty()) {
     output.append(" ");
     estimatedWidth++;
   }
   logFormat_ = output;
   staticEstimatedWidth_ = estimatedWidth;
 
   // populate singleLineLogFormat_ with the padded line format.
   if (colored_) {
     singleLineLogFormat_ = folly::to<std::string>(
         "{",
         messageIndex + 1,
         "}",
         logFormat_,
         "{",
         messageIndex,
         "}{",
         messageIndex + 2,
         "}\n");
   } else {
     singleLineLogFormat_ =
         folly::to<std::string>(logFormat_, "{", messageIndex, "}\n");
   }
 }