Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ec41a069 authored by android-build-team Robot's avatar android-build-team Robot Committed by Android (Google) Code Review
Browse files

Merge "Reset statsd and correctly record the dump reason when system server... 

Merge "Reset statsd and correctly record the dump reason when system server restarts/crashes." into pi-dev
parents 1e9761df 892f3d32

cmds/statsd/src/StatsLogProcessor.cpp

+26 −14
Original line number Diff line number Diff line
@@ -162,6 +162,19 @@ void StatsLogProcessor::OnLogEvent(LogEvent* event) { 
    OnLogEvent(event, false);

}



void StatsLogProcessor::resetConfigs() {

    std::lock_guard<std::mutex> lock(mMetricsMutex);

    resetConfigsLocked(getElapsedRealtimeNs());

}



void StatsLogProcessor::resetConfigsLocked(const int64_t timestampNs) {

    std::vector<ConfigKey> configKeys;

    for (auto it = mMetricsManagers.begin(); it != mMetricsManagers.end(); it++) {

        configKeys.push_back(it->first);

    }

    resetConfigsLocked(timestampNs, configKeys);

}



void StatsLogProcessor::OnLogEvent(LogEvent* event, bool reconnected) {

    std::lock_guard<std::mutex> lock(mMetricsMutex);

    const int64_t currentTimestampNs = event->GetElapsedTimestampNs();
@@ -188,11 +201,7 @@ void StatsLogProcessor::OnLogEvent(LogEvent* event, bool reconnected) { 
            WriteDataToDiskLocked(CONFIG_RESET);

            // We see fresher event before we see the checkpoint. We might have lost data.

            // The best we can do is to reset.

            std::vector<ConfigKey> configKeys;

            for (auto it = mMetricsManagers.begin(); it != mMetricsManagers.end(); it++) {

                configKeys.push_back(it->first);

            }

            resetConfigsLocked(currentTimestampNs, configKeys);

            resetConfigsLocked(currentTimestampNs);

        } else {

            // Still in search of the CP. Keep going.

            return;
@@ -242,6 +251,7 @@ void StatsLogProcessor::OnLogEvent(LogEvent* event, bool reconnected) { 
void StatsLogProcessor::OnConfigUpdated(const int64_t timestampNs, const ConfigKey& key,

                                        const StatsdConfig& config) {

    std::lock_guard<std::mutex> lock(mMetricsMutex);

    WriteDataToDiskLocked(key, timestampNs, CONFIG_UPDATED);

    OnConfigUpdatedLocked(timestampNs, key, config);

}
@@ -251,10 +261,6 @@ void StatsLogProcessor::OnConfigUpdatedLocked( 
    sp<MetricsManager> newMetricsManager =

        new MetricsManager(key, config, mTimeBaseNs, timestampNs, mUidMap,

                           mAnomalyAlarmMonitor, mPeriodicAlarmMonitor);

    auto it = mMetricsManagers.find(key);

    if (it != mMetricsManagers.end()) {

        WriteDataToDiskLocked(it->first, CONFIG_UPDATED);

    }

    if (newMetricsManager->isConfigValid()) {

        mUidMap->OnConfigUpdated(key);

        if (newMetricsManager->shouldAddUidMapListener()) {
@@ -419,6 +425,7 @@ void StatsLogProcessor::resetIfConfigTtlExpiredLocked(const int64_t timestampNs) 
        }

    }

    if (configKeysTtlExpired.size() > 0) {

        WriteDataToDiskLocked(CONFIG_RESET);

        resetConfigsLocked(timestampNs, configKeysTtlExpired);

    }

}
@@ -427,7 +434,7 @@ void StatsLogProcessor::OnConfigRemoved(const ConfigKey& key) { 
    std::lock_guard<std::mutex> lock(mMetricsMutex);

    auto it = mMetricsManagers.find(key);

    if (it != mMetricsManagers.end()) {

        WriteDataToDiskLocked(key, CONFIG_REMOVED);

        WriteDataToDiskLocked(key, getElapsedRealtimeNs(), CONFIG_REMOVED);

        mMetricsManagers.erase(it);

        mUidMap->OnConfigRemoved(key);

    }
@@ -474,9 +481,13 @@ void StatsLogProcessor::flushIfNecessaryLocked( 
}



void StatsLogProcessor::WriteDataToDiskLocked(const ConfigKey& key,

                                              const int64_t timestampNs,

                                              const DumpReportReason dumpReportReason) {

    if (mMetricsManagers.find(key) == mMetricsManagers.end()) {

        return;

    }

    ProtoOutputStream proto;

    onConfigMetricsReportLocked(key, getElapsedRealtimeNs(),

    onConfigMetricsReportLocked(key, timestampNs,

                                true /* include_current_partial_bucket*/,

                                false /* include strings */, dumpReportReason, &proto);

    string file_name = StringPrintf("%s/%ld_%d_%lld", STATS_DATA_DIR,
@@ -491,14 +502,15 @@ void StatsLogProcessor::WriteDataToDiskLocked(const ConfigKey& key, 
}



void StatsLogProcessor::WriteDataToDiskLocked(const DumpReportReason dumpReportReason) {

    const int64_t timeNs = getElapsedRealtimeNs();

    for (auto& pair : mMetricsManagers) {

        WriteDataToDiskLocked(pair.first, dumpReportReason);

        WriteDataToDiskLocked(pair.first, timeNs, dumpReportReason);

    }

}



void StatsLogProcessor::WriteDataToDisk(bool isShutdown) {

void StatsLogProcessor::WriteDataToDisk(const DumpReportReason dumpReportReason) {

    std::lock_guard<std::mutex> lock(mMetricsMutex);

    WriteDataToDiskLocked(DEVICE_SHUTDOWN);

    WriteDataToDiskLocked(dumpReportReason);

}



void StatsLogProcessor::informPullAlarmFired(const int64_t timestampNs) {

cmds/statsd/src/StatsLogProcessor.h

+10 −3
Original line number Diff line number Diff line
@@ -77,7 +77,10 @@ public: 
            unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>> alarmSet);



    /* Flushes data to disk. Data on memory will be gone after written to disk. */

    void WriteDataToDisk(bool shutdown);

    void WriteDataToDisk(const DumpReportReason dumpReportReason);



    // Reset all configs.

    void resetConfigs();



    inline sp<UidMap> getUidMap() {

        return mUidMap;
@@ -121,8 +124,9 @@ private: 
    void OnConfigUpdatedLocked(

        const int64_t currentTimestampNs, const ConfigKey& key, const StatsdConfig& config);



    void WriteDataToDiskLocked(DumpReportReason dumpReportReason);

    void WriteDataToDiskLocked(const ConfigKey& key, DumpReportReason dumpReportReason);

    void WriteDataToDiskLocked(const DumpReportReason dumpReportReason);

    void WriteDataToDiskLocked(const ConfigKey& key, const int64_t timestampNs,

                               const DumpReportReason dumpReportReason);



    void onConfigMetricsReportLocked(const ConfigKey& key, const int64_t dumpTimeStampNs,

                                     const bool include_current_partial_bucket,
@@ -141,6 +145,9 @@ private: 
    // Handler over the isolated uid change event.

    void onIsolatedUidChangedEventLocked(const LogEvent& event);



    // Reset all configs.

    void resetConfigsLocked(const int64_t timestampNs);

    // Reset the specified configs.

    void resetConfigsLocked(const int64_t timestampNs, const std::vector<ConfigKey>& configs);



    // Function used to send a broadcast so that receiver for the config key can call getData

cmds/statsd/src/StatsService.cpp

+9 −4
Original line number Diff line number Diff line
@@ -659,7 +659,7 @@ status_t StatsService::cmd_print_uid_map(FILE* out, const Vector<String8>& args) 


status_t StatsService::cmd_write_data_to_disk(FILE* out) {

    fprintf(out, "Writing data to disk\n");

    mProcessor->WriteDataToDisk(false);

    mProcessor->WriteDataToDisk(ADB_DUMP);

    return NO_ERROR;

}
@@ -816,10 +816,10 @@ Status StatsService::systemRunning() { 
    return Status::ok();

}



Status StatsService::informDeviceShutdown(bool isShutdown) {

Status StatsService::informDeviceShutdown() {

    ENFORCE_UID(AID_SYSTEM);

    VLOG("StatsService::informDeviceShutdown");

    mProcessor->WriteDataToDisk(isShutdown);

    mProcessor->WriteDataToDisk(DEVICE_SHUTDOWN);

    return Status::ok();

}
@@ -967,7 +967,12 @@ Status StatsService::unsetBroadcastSubscriber(int64_t configId, 


void StatsService::binderDied(const wp <IBinder>& who) {

    ALOGW("statscompanion service died");

    StatsdStats::getInstance().noteSystemServerRestart(getWallClockSec());

    if (mProcessor != nullptr) {

        ALOGW("Reset statsd upon system server restars.");

        mProcessor->WriteDataToDisk(STATSCOMPANION_DIED);

        mProcessor->resetConfigs();

    }

    mAnomalyAlarmMonitor->setStatsCompanionService(nullptr);

    mPeriodicAlarmMonitor->setStatsCompanionService(nullptr);

    SubscriberReporter::getInstance().setStatsCompanionService(nullptr);

cmds/statsd/src/StatsService.h

+1 −1
Original line number Diff line number Diff line
@@ -66,7 +66,7 @@ public: 
                                    const vector<String16>& app);

    virtual Status informOnePackage(const String16& app, int32_t uid, int64_t version);

    virtual Status informOnePackageRemoved(const String16& app, int32_t uid);

    virtual Status informDeviceShutdown(bool isShutdown);

    virtual Status informDeviceShutdown();



    /**

     * Called right before we start processing events.

cmds/statsd/src/guardrail/StatsdStats.cpp

+23 −1
Original line number Diff line number Diff line
@@ -51,6 +51,7 @@ const int FIELD_ID_ANOMALY_ALARM_STATS = 9; 
const int FIELD_ID_LOGGER_ERROR_STATS = 11;

const int FIELD_ID_PERIODIC_ALARM_STATS = 12;

const int FIELD_ID_LOG_LOSS_STATS = 14;

const int FIELD_ID_SYSTEM_SERVER_RESTART = 15;



const int FIELD_ID_ATOM_STATS_TAG = 1;

const int FIELD_ID_ATOM_STATS_COUNT = 2;
@@ -355,6 +356,15 @@ void StatsdStats::noteAtomLogged(int atomId, int32_t timeSec) { 
    mPushedAtomStats[atomId]++;

}



void StatsdStats::noteSystemServerRestart(int32_t timeSec) {

    lock_guard<std::mutex> lock(mLock);



    if (mSystemServerRestartSec.size() == kMaxSystemServerRestarts) {

        mSystemServerRestartSec.pop_front();

    }

    mSystemServerRestartSec.push_back(timeSec);

}



void StatsdStats::noteLoggerError(int error) {

    lock_guard<std::mutex> lock(mLock);

    // grows strictly one at a time. so it won't > kMaxLoggerErrors
@@ -377,6 +387,7 @@ void StatsdStats::resetInternalLocked() { 
    mAnomalyAlarmRegisteredStats = 0;

    mPeriodicAlarmRegisteredStats = 0;

    mLoggerErrors.clear();

    mSystemServerRestartSec.clear();

    mLogLossTimestampNs.clear();

    for (auto& config : mConfigStats) {

        config.second->broadcast_sent_time_sec.clear();
@@ -395,7 +406,7 @@ string buildTimeString(int64_t timeSec) { 
    time_t t = timeSec;

    struct tm* tm = localtime(&t);

    char timeBuffer[80];

    strftime(timeBuffer, sizeof(timeBuffer), "%Y-%m-%d %I:%M%p\n", tm);

    strftime(timeBuffer, sizeof(timeBuffer), "%Y-%m-%d %I:%M%p", tm);

    return string(timeBuffer);

}
@@ -511,6 +522,12 @@ void StatsdStats::dumpStats(FILE* out) const { 
        strftime(buffer, sizeof(buffer), "%Y-%m-%d %I:%M%p\n", error_tm);

        fprintf(out, "Logger error %d at %s\n", error.second, buffer);

    }



    for (const auto& restart : mSystemServerRestartSec) {

        fprintf(out, "System server restarts at %s(%lld)\n",

            buildTimeString(restart).c_str(), (long long)restart);

    }



    for (const auto& loss : mLogLossTimestampNs) {

        fprintf(out, "Log loss detected at %lld (elapsedRealtimeNs)\n", (long long)loss);

    }
@@ -673,6 +690,11 @@ void StatsdStats::dumpStats(std::vector<uint8_t>* output, bool reset) { 
                    (long long)loss);

    }



    for (const auto& restart : mSystemServerRestartSec) {

        proto.write(FIELD_TYPE_INT32 | FIELD_ID_SYSTEM_SERVER_RESTART | FIELD_COUNT_REPEATED,

                    restart);

    }



    output->clear();

    size_t bufferSize = proto.size();

    output->resize(bufferSize);