LogMessage.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 <sys/types.h>
#include <chrono>
#include <string>

#include <folly/Range.h>
#include <folly/logging/LogLevel.h>

namespace folly {

class LogCategory;

class LogMessage {
 public:
  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(
            category,
            level,
            filename,
            lineNumber,
            functionName,
            msg.str()) {}

  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 {
    return category_;
  }

  LogLevel getLevel() const {
    return level_;
  }

  folly::StringPiece getFileName() const {
    return filename_;
  }
  folly::StringPiece getFileBaseName() const;

  unsigned int getLineNumber() const {
    return lineNumber_;
  }

  folly::StringPiece getFunctionName() const {
    return functionName_;
  }

  std::chrono::system_clock::time_point getTimestamp() const {
    return timestamp_;
  }

  uint64_t getThreadID() const {
    return threadID_;
  }

  const std::string& getMessage() const {
    // If no characters needed to be sanitized, message_ will be empty.
    if (message_.empty()) {
      return rawMessage_;
    }
    return message_;
  }

  const std::string& getRawMessage() const {
    return rawMessage_;
  }

  bool containsNewlines() const {
    return containsNewlines_;
  }

 private:
  void sanitizeMessage();

  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_;
};
} // namespace folly