Method onANR

valdi/src/valdi/runtime/JavaScript/JavaScriptANRDetector.cpp:131–199

    _tickInterval = tickInterval;
}

void JavaScriptANRDetector::onNextTick(DispatchFunction nextTickCallback) {
    std::lock_guard<Mutex> lock(_mutex);
    _nextTickCallbacks.emplace_back(std::move(nextTickCallback));
}

void JavaScriptANRDetector::scheduleNextTick() {
    if (_nextTickTask != 0 || !_started || !_isInForeground) {
        return;
    }
    _nextTickTask = _dispatchQueue->asyncAfter(
        [self = Valdi::weakRef(this)]() {
            auto strongSelf = self.lock();
            if (strongSelf != nullptr) {
                strongSelf->checkForANRs();
            }
        },
        _tickInterval);
}

bool JavaScriptANRDetector::onANR(JavaScriptTaskScheduler& taskScheduler,
                                  std::chrono::steady_clock::duration detectionThreshold,
                                  const std::atomic<bool>& ack) {
    // Read the native-side attribution before waiting on the stack capture. The capture can take up
    // to kCaptureStacktraceTimeoutSeconds, and a native call or module load that finishes during
    // that wait clears its name, which would report the stall as unattributed. Both getters read
    // saved native state, not JS, so they are safe to call while the JS thread is stuck.
    auto loadingModule = taskScheduler.getCurrentlyLoadingModule();
    auto attributionInfo = taskScheduler.getANRAttributionInfo();
    auto stacktraces = taskScheduler.captureStackTraces(std::chrono::seconds(kCaptureStacktraceTimeoutSeconds));
    StringBox moduleName;
    std::string message;

    if (!stacktraces.empty() && stacktraces[0].getContext() != nullptr) {
        moduleName = stacktraces[0].getContext()->getPath().getResourceId().bundleName;
    }

    // Module loads run under the global context (no bundle name) and expose no JS stack while the
    // bundle is being parsed, so a load that holds the JS thread past the threshold would
    // otherwise be reported unattributed. Attribute it to the bundle being loaded instead.
    bool isLoadingModule = false;
    if (moduleName.isEmpty()) {
        moduleName = loadingModule;
        isLoadingModule = !moduleName.isEmpty();
    }

    if (!hasRunningStacktrace(stacktraces) && ack.load()) {
        // The ack was submitted while waiting to capture stacktraces.
        // We consider that task scheduler has recovered
        return true;
    }

    auto detectionThresholdString =
        snap::utils::time::Duration<std::chrono::steady_clock>(detectionThreshold).toString();
    if (moduleName.isEmpty()) {
        message = fmt::format("Detected unattributed ANR after {}", detectionThresholdString);
    } else if (isLoadingModule) {
        message =