2 * Copyright 2017 Facebook, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #include <folly/experimental/exception_tracer/ExceptionCounterLib.h>
20 #include <unordered_map>
22 #include <folly/RWSpinLock.h>
23 #include <folly/Range.h>
24 #include <folly/Synchronized.h>
25 #include <folly/ThreadLocal.h>
26 #include <folly/hash/SpookyHashV2.h>
28 #include <folly/experimental/exception_tracer/ExceptionTracerLib.h>
29 #include <folly/experimental/exception_tracer/StackTrace.h>
30 #include <folly/experimental/symbolizer/Symbolizer.h>
32 using namespace folly::exception_tracer;
36 // We use the hash of stack trace and exception type to uniquely
37 // identify the exception.
38 using ExceptionId = uint64_t;
40 using ExceptionStatsHolderType =
41 std::unordered_map<ExceptionId, ExceptionStats>;
43 struct ExceptionStatsStorage {
44 void appendTo(ExceptionStatsHolderType& data) {
45 ExceptionStatsHolderType tempHolder;
46 statsHolder->swap(tempHolder);
48 for (const auto& myData : tempHolder) {
49 auto inserted = data.insert(myData);
50 if (!inserted.second) {
51 inserted.first->second.count += myData.second.count;
56 folly::Synchronized<ExceptionStatsHolderType, folly::RWSpinLock> statsHolder;
61 folly::ThreadLocal<ExceptionStatsStorage, Tag> gExceptionStats;
66 namespace exception_tracer {
68 std::vector<ExceptionStats> getExceptionStatistics() {
69 ExceptionStatsHolderType accumulator;
70 for (auto& threadStats : gExceptionStats.accessAllThreads()) {
71 threadStats.appendTo(accumulator);
74 std::vector<ExceptionStats> result;
75 result.reserve(accumulator.size());
76 for (auto& item : accumulator) {
77 result.push_back(std::move(item.second));
80 std::sort(result.begin(),
82 [](const ExceptionStats& lhs, const ExceptionStats& rhs) {
83 return lhs.count > rhs.count;
89 std::ostream& operator<<(std::ostream& out, const ExceptionStats& stats) {
90 out << "Exception report: \n"
91 << "Exception count: " << stats.count << "\n"
97 } // namespace exception_tracer
103 * This handler gathers statistics on all exceptions thrown by the program
104 * Information is being stored in thread local storage.
106 void throwHandler(void*, std::type_info* exType, void (*)(void*)) noexcept {
107 // This array contains the exception type and the stack frame
108 // pointers so they get all hashed together.
109 uintptr_t frames[kMaxFrames + 1];
110 frames[0] = reinterpret_cast<uintptr_t>(exType);
111 auto n = folly::symbolizer::getStackTrace(frames + 1, kMaxFrames);
114 // If we fail to collect the stack trace for this exception we
115 // just log it under empty stack trace.
120 folly::hash::SpookyHashV2::Hash64(frames, (n + 1) * sizeof(frames[0]), 0);
122 SYNCHRONIZED(holder, gExceptionStats->statsHolder) {
123 auto it = holder.find(exceptionId);
124 if (it != holder.end()) {
129 info.frames.assign(frames + 1, frames + 1 + n);
130 holder.emplace(exceptionId, ExceptionStats{1, std::move(info)});
136 Initializer() { registerCxaThrowCallback(throwHandler); }
139 Initializer initializer;