folly::exception_tracer Namespace Reference

Namespaces
	detail

Classes
struct	ExceptionInfo
struct	ExceptionStats
struct	StackTrace
class	StackTraceStack

Typedefs
using	CxaThrowType = decltype(&detail::dummyCxaThrow)
using	CxaBeginCatchType = decltype(&detail::dummyCxaBeginCatch)
using	CxaRethrowType = decltype(&detail::dummyCxaRethrow)
using	CxaEndCatchType = decltype(&detail::dummyCxaEndCatch)
using	RethrowExceptionType = decltype(&detail::dummyRethrowException)

Functions
std::vector< ExceptionStats >	getExceptionStatistics ()
std::ostream &	operator<< (std::ostream &out, const ExceptionStats &stats)
std::ostream &	operator<< (std::ostream &out, const ExceptionInfo &info)
void	printExceptionInfo (std::ostream &out, const ExceptionInfo &info, int options)
std::vector< ExceptionInfo >	getCurrentExceptions ()
void	installHandlers ()
CallbackHolder< CxaThrowType > &	getCxaThrowCallbacks ()
void	registerCxaThrowCallback (CxaThrowType callback)
CallbackHolder< CxaBeginCatchType > &	getCxaBeginCatchCallbacks ()
void	registerCxaBeginCatchCallback (CxaBeginCatchType callback)
CallbackHolder< CxaRethrowType > &	getCxaRethrowCallbacks ()
void	registerCxaRethrowCallback (CxaRethrowType callback)
CallbackHolder< CxaEndCatchType > &	getCxaEndCatchCallbacks ()
void	registerCxaEndCatchCallback (CxaEndCatchType callback)
CallbackHolder< RethrowExceptionType > &	getRethrowExceptionCallbacks ()
void	registerRethrowExceptionCallback (RethrowExceptionType callback)

Variables
constexpr size_t	kMaxFrames = 500

Typedef Documentation

using folly::exception_tracer::CxaBeginCatchType = typedef decltype(&detail::dummyCxaBeginCatch)

Definition at line 40 of file ExceptionTracerLib.h.

using folly::exception_tracer::CxaEndCatchType = typedef decltype(&detail::dummyCxaEndCatch)

Definition at line 42 of file ExceptionTracerLib.h.

using folly::exception_tracer::CxaRethrowType = typedef decltype(&detail::dummyCxaRethrow)

Definition at line 41 of file ExceptionTracerLib.h.

using folly::exception_tracer::CxaThrowType = typedef decltype(&detail::dummyCxaThrow)

Definition at line 39 of file ExceptionTracerLib.h.

using folly::exception_tracer::RethrowExceptionType = typedef decltype(&detail::dummyRethrowException)

Definition at line 43 of file ExceptionTracerLib.h.

Function Documentation

std::vector< ExceptionInfo > folly::exception_tracer::getCurrentExceptions

(

)

Get current exceptions being handled. front() is the most recent exception. There should be at most one unless rethrowing.

Definition at line 112 of file ExceptionTracer.cpp.

References __cxxabiv1::__cxa_get_globals(), folly::exception_tracer::StackTrace::addresses, __cxxabiv1::__cxa_eh_globals::caughtExceptions, folly::demangle(), folly::DFATAL, folly::exception_tracer::StackTrace::frameCount, folly::exception_tracer::ExceptionInfo::frames, getExceptionStackTraceStack(), deadlock::info(), folly::gen::move, folly::exception_tracer::StackTraceStack::next(), prefix(), folly::exception_tracer::StackTraceStack::top(), folly::exception_tracer::ExceptionInfo::type, and folly::WARNING.

Referenced by dumpExceptions(), and loop().

                                                {
  struct Once {
    Once() {
      // See if linked in with us (getExceptionStackTraceStack is weak)
      getExceptionStackTraceStackFn = getExceptionStackTraceStack;

      if (!getExceptionStackTraceStackFn) {
        // Nope, see if it's in a shared library
        getExceptionStackTraceStackFn = (GetExceptionStackTraceStackType)dlsym(
            RTLD_NEXT, "getExceptionStackTraceStack");
      }
    }
  };
  static Once once;

  std::vector<ExceptionInfo> exceptions;
  auto currentException = __cxa_get_globals()->caughtExceptions;
  if (!currentException) {
    return exceptions;
  }

  StackTraceStack* traceStack = nullptr;
  if (!getExceptionStackTraceStackFn) {
    static bool logged = false;
    if (!logged) {
      LOG(WARNING)
          << "Exception tracer library not linked, stack traces not available";
      logged = true;
    }
  } else if ((traceStack = getExceptionStackTraceStackFn()) == nullptr) {
    static bool logged = false;
    if (!logged) {
      LOG(WARNING)
          << "Exception stack trace invalid, stack traces not available";
      logged = true;
    }
  }

  StackTrace* trace = traceStack ? traceStack->top() : nullptr;
  while (currentException) {
    ExceptionInfo info;
    // Dependent exceptions (thrown via std::rethrow_exception) aren't
    // standard ABI __cxa_exception objects, and are correctly labeled as
    // such in the exception_class field.  We could try to extract the
    // primary exception type in horribly hacky ways, but, for now, nullptr.
    info.type = isAbiCppException(currentException)
        ? currentException->exceptionType
        : nullptr;

    if (traceStack) {
      LOG_IF(DFATAL, !trace)
          << "Invalid trace stack for exception of type: "
          << (info.type ? folly::demangle(*info.type) : "null");

      if (!trace) {
        return {};
      }

      info.frames.assign(
          trace->addresses, trace->addresses + trace->frameCount);
      trace = traceStack->next(trace);
    }
    currentException = currentException->nextException;
    exceptions.push_back(std::move(info));
  }

  LOG_IF(DFATAL, trace) << "Invalid trace stack!";

  return exceptions;
}

CallbackHolder< CxaBeginCatchType>& folly::exception_tracer::getCxaBeginCatchCallbacks

(

)

Definition at line 81 of file ExceptionTracerLib.cpp.

Referenced by __cxxabiv1::__cxa_begin_catch().

{

CallbackHolder< CxaEndCatchType>& folly::exception_tracer::getCxaEndCatchCallbacks

(

)

Definition at line 83 of file ExceptionTracerLib.cpp.

Referenced by __cxxabiv1::__cxa_end_catch().

{

CallbackHolder< CxaRethrowType>& folly::exception_tracer::getCxaRethrowCallbacks

(

)

Definition at line 82 of file ExceptionTracerLib.cpp.

Referenced by __cxxabiv1::__cxa_rethrow().

{

CallbackHolder< CxaThrowType>& folly::exception_tracer::getCxaThrowCallbacks

(

)

Definition at line 80 of file ExceptionTracerLib.cpp.

Referenced by __cxxabiv1::__cxa_throw().

{

std::vector< ExceptionStats > folly::exception_tracer::getExceptionStatistics

(

)

This function accumulates exception throwing statistics across all threads. Please note, that during call to this function, other threads might block on exception throws, so it should be called seldomly. All pef-thread statistics is being reset by the call.

Definition at line 67 of file ExceptionCounterLib.cpp.

References folly::exception_tracer::ExceptionStats::count, folly::gen::move, and folly::detail::rhs.

Referenced by TEST().

                                                   {
  ExceptionStatsHolderType accumulator;
  for (auto& threadStats : gExceptionStats.accessAllThreads()) {
    threadStats.appendTo(accumulator);
  }

  std::vector<ExceptionStats> result;
  result.reserve(accumulator.size());
  for (auto& item : accumulator) {
    result.push_back(std::move(item.second));
  }

  std::sort(
      result.begin(),
      result.end(),
      [](const ExceptionStats& lhs, const ExceptionStats& rhs) {
        return lhs.count > rhs.count;
      });

  return result;
}

CallbackHolder< RethrowExceptionType>& folly::exception_tracer::getRethrowExceptionCallbacks

(

)

Definition at line 84 of file ExceptionTracerLib.cpp.

Referenced by std::rethrow_exception().

{

void folly::exception_tracer::installHandlers

(

)

Install the terminate / unexpected handlers to dump exceptions.

Definition at line 212 of file ExceptionTracer.cpp.

Referenced by getExceptionStackTraceStack().

                       {
  struct Once {
    Once() {
      origTerminate = std::set_terminate(terminateHandler);
      origUnexpected = std::set_unexpected(unexpectedHandler);
    }
  };
  static Once once;
}

std::ostream & folly::exception_tracer::operator<<	(	std::ostream &	out,
		const ExceptionInfo &	info
	)

Definition at line 48 of file ExceptionTracer.cpp.

References printExceptionInfo().

                                                                   {
  printExceptionInfo(out, info, SymbolizePrinter::COLOR_IF_TTY);
  return out;
}

std::ostream & folly::exception_tracer::operator<<	(	std::ostream &	out,
		const ExceptionStats &	stats
	)

Definition at line 89 of file ExceptionCounterLib.cpp.

References folly::exception_tracer::ExceptionStats::count, folly::exception_tracer::ExceptionInfo::frames, folly::symbolizer::getStackTrace(), folly::hash::SpookyHashV2::Hash64(), folly::exception_tracer::ExceptionStats::info, deadlock::info(), kMaxFrames, folly::gen::move, folly::pushmi::__adl::noexcept(), registerCxaThrowCallback(), and folly::exception_tracer::ExceptionInfo::type.

                                                                     {
  out << "Exception report: \n"
      << "Exception count: " << stats.count << "\n"
      << stats.info;

  return out;
}

void folly::exception_tracer::printExceptionInfo	(	std::ostream &	out,
		const ExceptionInfo &	info,
		int	options
	)

Definition at line 53 of file ExceptionTracer.cpp.

References folly::demangle(), folly::exceptionStr(), folly::exception_tracer::ExceptionInfo::frames, folly::exception_tracer::ExceptionInfo::type, uint64_t, and __cxxabiv1::__cxa_exception::unwindHeader.

Referenced by operator<<().

                 {
  out << "Exception type: ";
  if (info.type) {
    out << folly::demangle(*info.type);
  } else {
    out << "(unknown type)";
  }
  out << " (" << info.frames.size()
      << (info.frames.size() == 1 ? " frame" : " frames") << ")\n";
  try {
    size_t frameCount = info.frames.size();

    // Skip our own internal frames
    static constexpr size_t kInternalFramesNumber = 3;
    if (frameCount > kInternalFramesNumber) {
      auto addresses = info.frames.data() + kInternalFramesNumber;
      frameCount -= kInternalFramesNumber;

      std::vector<SymbolizedFrame> frames;
      frames.resize(frameCount);

      Symbolizer symbolizer(
          (options & SymbolizePrinter::NO_FILE_AND_LINE)
              ? Dwarf::LocationInfoMode::DISABLED
              : Symbolizer::kDefaultLocationInfoMode);
      symbolizer.symbolize(addresses, frames.data(), frameCount);

      OStreamSymbolizePrinter osp(out, options);
      osp.println(addresses, frames.data(), frameCount);
    }
  } catch (const std::exception& e) {
    out << "\n !! caught " << folly::exceptionStr(e) << "\n";
  } catch (...) {
    out << "\n !!! caught unexpected exception\n";
  }
}

void folly::exception_tracer::registerCxaBeginCatchCallback

(

CxaBeginCatchType

callback

)

Definition at line 81 of file ExceptionTracerLib.cpp.

Referenced by getExceptionStackTraceStack().

{

void folly::exception_tracer::registerCxaEndCatchCallback

(

CxaEndCatchType

callback

)

Definition at line 83 of file ExceptionTracerLib.cpp.

Referenced by getExceptionStackTraceStack().

{

void folly::exception_tracer::registerCxaRethrowCallback

(

CxaRethrowType

callback

)

Definition at line 82 of file ExceptionTracerLib.cpp.

Referenced by getExceptionStackTraceStack().

{

void folly::exception_tracer::registerCxaThrowCallback

(

CxaThrowType

callback

)

Definition at line 80 of file ExceptionTracerLib.cpp.

Referenced by getExceptionStackTraceStack(), and operator<<().

{

void folly::exception_tracer::registerRethrowExceptionCallback

(

RethrowExceptionType

callback

)

Definition at line 84 of file ExceptionTracerLib.cpp.

Referenced by getExceptionStackTraceStack().

{

Variable Documentation

constexpr size_t folly::exception_tracer::kMaxFrames = 500

Definition at line 26 of file StackTrace.h.

Referenced by operator<<(), and folly::exception_tracer::StackTraceStack::pushCurrent().