folly::GlogStyleFormatter Class Reference

#include <GlogStyleFormatter.h>

Inheritance diagram for folly::GlogStyleFormatter:

Public Member Functions
std::string	formatMessage (const LogMessage &message, const LogCategory *handlerCategory) override
Public Member Functions inherited from folly::LogFormatter
virtual	~LogFormatter ()

Detailed Description

A LogFormatter implementation that produces messages in a format similar to that produced by the Google logging library.

The glog message format is:

LmmDD HH:MM:SS.USECS THREAD [THREADNAME] (THREADCTX) FILE:LINE] MSG

L: A 1-character code describing the log level (e.g., E, W, I, V) mm: 2-digit month DD: 2-digit day HH: 2-digit hour, 24-hour format MM: 2-digit minute SS: 2-digit second USECS: 6-digit microseconds THREAD: Thread ID FILE: Filename (just the last component) LINE: Line number MSG: The actual log message

[THREADNAME] is the thread name, and is only included if –logthreadnames was enabled on the command line.

(THREADCTX) is thread-local log context data, if it has been set. (This is a Facebook-specific modification, and is disabled unless –logthreadcontext was enabled on the command line.)

Exception information and a custom log prefix may also appear after the file name and line number, before the ']' character.

Definition at line 53 of file GlogStyleFormatter.h.

Member Function Documentation

std::string folly::GlogStyleFormatter::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 45 of file GlogStyleFormatter.cpp.

References buffer(), folly::LogMessage::containsNewlines(), folly::test::end(), folly::format(), folly::LogMessage::getFileBaseName(), folly::LogMessage::getLevel(), folly::LogMessage::getLineNumber(), folly::LogMessage::getMessage(), folly::LogMessage::getThreadID(), folly::LogMessage::getTimestamp(), folly::Range< const char * >::npos, and string.

                          {
  // 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();
  auto headerFormatter = folly::format(
      "{}{:02d}{:02d} {:02d}:{:02d}:{:02d}.{:06d} {:5d} {}:{}] ",
      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.getLineNumber());

  // TODO: Support including thread names and thread context info.

  // The fixed portion of the header takes up 31 bytes.
  //
  // The variable portions that we can't account for here include the line
  // number and the thread ID (just in case it is larger than 6 digits long).
  // Here we guess that 40 bytes will be long enough to include room for this.
  //
  // 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 = 40 + basename.size();

  // Format the data into a buffer.
  std::string buffer;
  StringPiece msgData{message.getMessage()};
  if (message.containsNewlines()) {
    // If there are multiple lines in the log message, add a header
    // before each one.
    std::string header;
    header.reserve(headerLengthGuess);
    headerFormatter.appendTo(header);

    // 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(((header.size() + 1) * numLinesGuess) + msgData.size());

    size_t idx = 0;
    while (true) {
      auto end = msgData.find('\n', idx);
      if (end == StringPiece::npos) {
        end = msgData.size();
      }

      buffer.append(header);
      auto line = msgData.subpiece(idx, end - idx);
      buffer.append(line.data(), line.size());
      buffer.push_back('\n');

      if (end == msgData.size()) {
        break;
      }
      idx = end + 1;
    }
  } else {
    buffer.reserve(headerLengthGuess + msgData.size());
    headerFormatter.appendTo(buffer);
    buffer.append(msgData.data(), msgData.size());
    buffer.push_back('\n');
  }

  return buffer;
}

---

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

• proxygen/folly/folly/logging/GlogStyleFormatter.h
• proxygen/folly/folly/logging/GlogStyleFormatter.cpp