folly::StandardLogHandlerFactory Class Reference

#include <StandardLogHandlerFactory.h>

Classes
class	FormatterFactory
class	OptionProcessor
class	WriterFactory

Public Types
using	Options = std::unordered_map< std::string, std::string >

Static Public Member Functions
static std::shared_ptr< StandardLogHandler >	createHandler (StringPiece type, WriterFactory *writerFactory, const Options &options)

Detailed Description

StandardLogHandlerFactory contains helper methods for LogHandlerFactory implementations that create StandardLogHandler objects.

StandardLogHandlerFactory does not derive from LogHandlerFactory itself.

Definition at line 35 of file StandardLogHandlerFactory.h.

Member Typedef Documentation

using folly::StandardLogHandlerFactory::Options = std::unordered_map<std::string, std::string>

Definition at line 37 of file StandardLogHandlerFactory.h.

Member Function Documentation

std::shared_ptr< StandardLogHandler > folly::StandardLogHandlerFactory::createHandler ( StringPiece  type, WriterFactory *  writerFactory, const Options &  options  )

static

Definition at line 92 of file StandardLogHandlerFactory.cpp.

References folly::StandardLogHandlerFactory::WriterFactory::createWriter(), folly::get_ptr(), handled, folly::join(), folly::StandardLogHandlerFactory::OptionProcessor::processOption(), folly::stringToLogLevel(), and type.

Referenced by folly::StreamHandlerFactory::createHandler(), folly::FileHandlerFactory::createHandler(), and folly::TestHandlerFactory::createHandler().

                            {
  std::unique_ptr<FormatterFactory> formatterFactory;

  // Get the log formatter type
  auto* formatterType = get_ptr(options, "formatter");
  if (!formatterType || *formatterType == "glog") {
    formatterFactory = std::make_unique<GlogFormatterFactory>();
  } else if (!formatterType || *formatterType == "custom") {
    formatterFactory = std::make_unique<CustomLogFormatterFactory>();
  } else {
    throw std::invalid_argument(
        to<string>("unknown log formatter type \"", *formatterType, "\""));
  }

  Optional<LogLevel> syncLevel;

  // Process the log formatter and log handler options
  std::vector<string> errors;
  for (const auto& entry : options) {
    bool handled = false;
    try {
      // Allow both the formatterFactory and writerFactory to consume an
      // option.  In general they probably should have mutually exclusive
      // option names, but we don't give precedence to one over the other here.
      handled |= formatterFactory->processOption(entry.first, entry.second);
      handled |= writerFactory->processOption(entry.first, entry.second);
    } catch (const std::exception& ex) {
      errors.push_back(to<string>(
          "error processing option \"", entry.first, "\": ", ex.what()));
      continue;
    }

    // We explicitly processed the "formatter" option above.
    handled |= handled || (entry.first == "formatter");

    // Process the "sync_level" option.
    if (entry.first == "sync_level") {
      try {
        syncLevel = stringToLogLevel(entry.second);
      } catch (const std::exception& ex) {
        errors.push_back(to<string>(
            "unable to parse value for option \"",
            entry.first,
            "\": ",
            ex.what()));
      }
      handled = true;
    }

    // Complain about unknown options.
    if (!handled) {
      errors.push_back(to<string>("unknown option \"", entry.first, "\""));
    }
  }

  if (!errors.empty()) {
    throw std::invalid_argument(join(", ", errors));
  }

  // Construct the formatter and writer
  auto writer = writerFactory->createWriter();
  auto formatter = formatterFactory->createFormatter(writer);

  if (syncLevel) {
    return std::make_shared<StandardLogHandler>(
        LogHandlerConfig{type, options}, formatter, writer, *syncLevel);
  } else {
    return std::make_shared<StandardLogHandler>(
        LogHandlerConfig{type, options}, formatter, writer);
  }
}

---

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

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