554 lines
22 KiB
C++
554 lines
22 KiB
C++
/*
|
|
* Copyright (C) 2017 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#define DEBUG false // STOPSHIP if true
|
|
#include "Log.h"
|
|
#include "statslog.h"
|
|
|
|
#include <android-base/file.h>
|
|
#include <dirent.h>
|
|
#include "StatsLogProcessor.h"
|
|
#include "stats_log_util.h"
|
|
#include "android-base/stringprintf.h"
|
|
#include "guardrail/StatsdStats.h"
|
|
#include "metrics/CountMetricProducer.h"
|
|
#include "external/StatsPullerManager.h"
|
|
#include "stats_util.h"
|
|
#include "storage/StorageManager.h"
|
|
|
|
#include <log/log_event_list.h>
|
|
#include <utils/Errors.h>
|
|
#include <utils/SystemClock.h>
|
|
|
|
using namespace android;
|
|
using android::base::StringPrintf;
|
|
using android::util::FIELD_COUNT_REPEATED;
|
|
using android::util::FIELD_TYPE_BOOL;
|
|
using android::util::FIELD_TYPE_FLOAT;
|
|
using android::util::FIELD_TYPE_INT32;
|
|
using android::util::FIELD_TYPE_INT64;
|
|
using android::util::FIELD_TYPE_MESSAGE;
|
|
using android::util::FIELD_TYPE_STRING;
|
|
using android::util::ProtoOutputStream;
|
|
using std::make_unique;
|
|
using std::unique_ptr;
|
|
using std::vector;
|
|
|
|
namespace android {
|
|
namespace os {
|
|
namespace statsd {
|
|
|
|
// for ConfigMetricsReportList
|
|
const int FIELD_ID_CONFIG_KEY = 1;
|
|
const int FIELD_ID_REPORTS = 2;
|
|
// for ConfigKey
|
|
const int FIELD_ID_UID = 1;
|
|
const int FIELD_ID_ID = 2;
|
|
// for ConfigMetricsReport
|
|
// const int FIELD_ID_METRICS = 1; // written in MetricsManager.cpp
|
|
const int FIELD_ID_UID_MAP = 2;
|
|
const int FIELD_ID_LAST_REPORT_ELAPSED_NANOS = 3;
|
|
const int FIELD_ID_CURRENT_REPORT_ELAPSED_NANOS = 4;
|
|
const int FIELD_ID_LAST_REPORT_WALL_CLOCK_NANOS = 5;
|
|
const int FIELD_ID_CURRENT_REPORT_WALL_CLOCK_NANOS = 6;
|
|
const int FIELD_ID_DUMP_REPORT_REASON = 8;
|
|
const int FIELD_ID_STRINGS = 9;
|
|
|
|
#define NS_PER_HOUR 3600 * NS_PER_SEC
|
|
|
|
#define STATS_DATA_DIR "/data/misc/stats-data"
|
|
|
|
// Cool down period for writing data to disk to avoid overwriting files.
|
|
#define WRITE_DATA_COOL_DOWN_SEC 5
|
|
|
|
StatsLogProcessor::StatsLogProcessor(const sp<UidMap>& uidMap,
|
|
const sp<StatsPullerManager>& pullerManager,
|
|
const sp<AlarmMonitor>& anomalyAlarmMonitor,
|
|
const sp<AlarmMonitor>& periodicAlarmMonitor,
|
|
const int64_t timeBaseNs,
|
|
const std::function<bool(const ConfigKey&)>& sendBroadcast)
|
|
: mUidMap(uidMap),
|
|
mPullerManager(pullerManager),
|
|
mAnomalyAlarmMonitor(anomalyAlarmMonitor),
|
|
mPeriodicAlarmMonitor(periodicAlarmMonitor),
|
|
mSendBroadcast(sendBroadcast),
|
|
mTimeBaseNs(timeBaseNs),
|
|
mLargestTimestampSeen(0),
|
|
mLastTimestampSeen(0) {
|
|
mPullerManager->ForceClearPullerCache();
|
|
}
|
|
|
|
StatsLogProcessor::~StatsLogProcessor() {
|
|
}
|
|
|
|
void StatsLogProcessor::onAnomalyAlarmFired(
|
|
const int64_t& timestampNs,
|
|
unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>> alarmSet) {
|
|
std::lock_guard<std::mutex> lock(mMetricsMutex);
|
|
for (const auto& itr : mMetricsManagers) {
|
|
itr.second->onAnomalyAlarmFired(timestampNs, alarmSet);
|
|
}
|
|
}
|
|
void StatsLogProcessor::onPeriodicAlarmFired(
|
|
const int64_t& timestampNs,
|
|
unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>> alarmSet) {
|
|
|
|
std::lock_guard<std::mutex> lock(mMetricsMutex);
|
|
for (const auto& itr : mMetricsManagers) {
|
|
itr.second->onPeriodicAlarmFired(timestampNs, alarmSet);
|
|
}
|
|
}
|
|
|
|
void updateUid(Value* value, int hostUid) {
|
|
int uid = value->int_value;
|
|
if (uid != hostUid) {
|
|
value->setInt(hostUid);
|
|
}
|
|
}
|
|
|
|
void StatsLogProcessor::mapIsolatedUidToHostUidIfNecessaryLocked(LogEvent* event) const {
|
|
if (android::util::AtomsInfo::kAtomsWithAttributionChain.find(event->GetTagId()) !=
|
|
android::util::AtomsInfo::kAtomsWithAttributionChain.end()) {
|
|
for (auto& value : *(event->getMutableValues())) {
|
|
if (value.mField.getPosAtDepth(0) > kAttributionField) {
|
|
break;
|
|
}
|
|
if (isAttributionUidField(value)) {
|
|
const int hostUid = mUidMap->getHostUidOrSelf(value.mValue.int_value);
|
|
updateUid(&value.mValue, hostUid);
|
|
}
|
|
}
|
|
} else {
|
|
auto it = android::util::AtomsInfo::kAtomsWithUidField.find(event->GetTagId());
|
|
if (it != android::util::AtomsInfo::kAtomsWithUidField.end()) {
|
|
int uidField = it->second; // uidField is the field number in proto,
|
|
// starting from 1
|
|
if (uidField > 0 && (int)event->getValues().size() >= uidField &&
|
|
(event->getValues())[uidField - 1].mValue.getType() == INT) {
|
|
Value& value = (*event->getMutableValues())[uidField - 1].mValue;
|
|
const int hostUid = mUidMap->getHostUidOrSelf(value.int_value);
|
|
updateUid(&value, hostUid);
|
|
} else {
|
|
ALOGE("Malformed log, uid not found. %s", event->ToString().c_str());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void StatsLogProcessor::onIsolatedUidChangedEventLocked(const LogEvent& event) {
|
|
status_t err = NO_ERROR, err2 = NO_ERROR, err3 = NO_ERROR;
|
|
bool is_create = event.GetBool(3, &err);
|
|
auto parent_uid = int(event.GetLong(1, &err2));
|
|
auto isolated_uid = int(event.GetLong(2, &err3));
|
|
if (err == NO_ERROR && err2 == NO_ERROR && err3 == NO_ERROR) {
|
|
if (is_create) {
|
|
mUidMap->assignIsolatedUid(isolated_uid, parent_uid);
|
|
} else {
|
|
mUidMap->removeIsolatedUid(isolated_uid);
|
|
}
|
|
} else {
|
|
ALOGE("Failed to parse uid in the isolated uid change event.");
|
|
}
|
|
}
|
|
|
|
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) {
|
|
std::lock_guard<std::mutex> lock(mMetricsMutex);
|
|
|
|
#ifdef VERY_VERBOSE_PRINTING
|
|
if (mPrintAllLogs) {
|
|
ALOGI("%s", event->ToString().c_str());
|
|
}
|
|
#endif
|
|
const int64_t currentTimestampNs = event->GetElapsedTimestampNs();
|
|
|
|
resetIfConfigTtlExpiredLocked(currentTimestampNs);
|
|
|
|
StatsdStats::getInstance().noteAtomLogged(
|
|
event->GetTagId(), event->GetElapsedTimestampNs() / NS_PER_SEC);
|
|
|
|
// Hard-coded logic to update the isolated uid's in the uid-map.
|
|
// The field numbers need to be currently updated by hand with atoms.proto
|
|
if (event->GetTagId() == android::util::ISOLATED_UID_CHANGED) {
|
|
onIsolatedUidChangedEventLocked(*event);
|
|
}
|
|
|
|
if (mMetricsManagers.empty()) {
|
|
return;
|
|
}
|
|
|
|
int64_t curTimeSec = getElapsedRealtimeSec();
|
|
if (curTimeSec - mLastPullerCacheClearTimeSec > StatsdStats::kPullerCacheClearIntervalSec) {
|
|
mPullerManager->ClearPullerCacheIfNecessary(curTimeSec * NS_PER_SEC);
|
|
mLastPullerCacheClearTimeSec = curTimeSec;
|
|
}
|
|
|
|
|
|
if (event->GetTagId() != android::util::ISOLATED_UID_CHANGED) {
|
|
// Map the isolated uid to host uid if necessary.
|
|
mapIsolatedUidToHostUidIfNecessaryLocked(event);
|
|
}
|
|
|
|
// pass the event to metrics managers.
|
|
for (auto& pair : mMetricsManagers) {
|
|
pair.second->onLogEvent(*event);
|
|
flushIfNecessaryLocked(event->GetElapsedTimestampNs(), pair.first, *(pair.second));
|
|
}
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
void StatsLogProcessor::OnConfigUpdatedLocked(
|
|
const int64_t timestampNs, const ConfigKey& key, const StatsdConfig& config) {
|
|
VLOG("Updated configuration for key %s", key.ToString().c_str());
|
|
sp<MetricsManager> newMetricsManager =
|
|
new MetricsManager(key, config, mTimeBaseNs, timestampNs, mUidMap, mPullerManager,
|
|
mAnomalyAlarmMonitor, mPeriodicAlarmMonitor);
|
|
if (newMetricsManager->isConfigValid()) {
|
|
mUidMap->OnConfigUpdated(key);
|
|
if (newMetricsManager->shouldAddUidMapListener()) {
|
|
// We have to add listener after the MetricsManager is constructed because it's
|
|
// not safe to create wp or sp from this pointer inside its constructor.
|
|
mUidMap->addListener(newMetricsManager.get());
|
|
}
|
|
newMetricsManager->refreshTtl(timestampNs);
|
|
mMetricsManagers[key] = newMetricsManager;
|
|
VLOG("StatsdConfig valid");
|
|
} else {
|
|
// If there is any error in the config, don't use it.
|
|
ALOGE("StatsdConfig NOT valid");
|
|
}
|
|
}
|
|
|
|
size_t StatsLogProcessor::GetMetricsSize(const ConfigKey& key) const {
|
|
std::lock_guard<std::mutex> lock(mMetricsMutex);
|
|
auto it = mMetricsManagers.find(key);
|
|
if (it == mMetricsManagers.end()) {
|
|
ALOGW("Config source %s does not exist", key.ToString().c_str());
|
|
return 0;
|
|
}
|
|
return it->second->byteSize();
|
|
}
|
|
|
|
void StatsLogProcessor::dumpStates(int out, bool verbose) {
|
|
std::lock_guard<std::mutex> lock(mMetricsMutex);
|
|
FILE* fout = fdopen(out, "w");
|
|
if (fout == NULL) {
|
|
return;
|
|
}
|
|
fprintf(fout, "MetricsManager count: %lu\n", (unsigned long)mMetricsManagers.size());
|
|
for (auto metricsManager : mMetricsManagers) {
|
|
metricsManager.second->dumpStates(fout, verbose);
|
|
}
|
|
|
|
fclose(fout);
|
|
}
|
|
|
|
/*
|
|
* onDumpReport dumps serialized ConfigMetricsReportList into proto.
|
|
*/
|
|
void StatsLogProcessor::onDumpReport(const ConfigKey& key, const int64_t dumpTimeStampNs,
|
|
const bool include_current_partial_bucket,
|
|
const bool erase_data,
|
|
const DumpReportReason dumpReportReason,
|
|
ProtoOutputStream* proto) {
|
|
std::lock_guard<std::mutex> lock(mMetricsMutex);
|
|
|
|
// Start of ConfigKey.
|
|
uint64_t configKeyToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_ID_CONFIG_KEY);
|
|
proto->write(FIELD_TYPE_INT32 | FIELD_ID_UID, key.GetUid());
|
|
proto->write(FIELD_TYPE_INT64 | FIELD_ID_ID, (long long)key.GetId());
|
|
proto->end(configKeyToken);
|
|
// End of ConfigKey.
|
|
|
|
// Then, check stats-data directory to see there's any file containing
|
|
// ConfigMetricsReport from previous shutdowns to concatenate to reports.
|
|
StorageManager::appendConfigMetricsReport(key, proto);
|
|
|
|
auto it = mMetricsManagers.find(key);
|
|
if (it != mMetricsManagers.end()) {
|
|
// This allows another broadcast to be sent within the rate-limit period if we get close to
|
|
// filling the buffer again soon.
|
|
mLastBroadcastTimes.erase(key);
|
|
|
|
// Start of ConfigMetricsReport (reports).
|
|
uint64_t reportsToken =
|
|
proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_REPORTS);
|
|
onConfigMetricsReportLocked(key, dumpTimeStampNs, include_current_partial_bucket,
|
|
erase_data, dumpReportReason, proto);
|
|
proto->end(reportsToken);
|
|
// End of ConfigMetricsReport (reports).
|
|
} else {
|
|
ALOGW("Config source %s does not exist", key.ToString().c_str());
|
|
}
|
|
}
|
|
|
|
/*
|
|
* onDumpReport dumps serialized ConfigMetricsReportList into outData.
|
|
*/
|
|
void StatsLogProcessor::onDumpReport(const ConfigKey& key, const int64_t dumpTimeStampNs,
|
|
const bool include_current_partial_bucket,
|
|
const bool erase_data,
|
|
const DumpReportReason dumpReportReason,
|
|
vector<uint8_t>* outData) {
|
|
ProtoOutputStream proto;
|
|
onDumpReport(key, dumpTimeStampNs, include_current_partial_bucket, erase_data,
|
|
dumpReportReason, &proto);
|
|
|
|
if (outData != nullptr) {
|
|
outData->clear();
|
|
outData->resize(proto.size());
|
|
size_t pos = 0;
|
|
auto iter = proto.data();
|
|
while (iter.readBuffer() != NULL) {
|
|
size_t toRead = iter.currentToRead();
|
|
std::memcpy(&((*outData)[pos]), iter.readBuffer(), toRead);
|
|
pos += toRead;
|
|
iter.rp()->move(toRead);
|
|
}
|
|
}
|
|
|
|
StatsdStats::getInstance().noteMetricsReportSent(key, proto.size());
|
|
}
|
|
|
|
/*
|
|
* onConfigMetricsReportLocked dumps serialized ConfigMetricsReport into outData.
|
|
*/
|
|
void StatsLogProcessor::onConfigMetricsReportLocked(const ConfigKey& key,
|
|
const int64_t dumpTimeStampNs,
|
|
const bool include_current_partial_bucket,
|
|
const bool erase_data,
|
|
const DumpReportReason dumpReportReason,
|
|
ProtoOutputStream* proto) {
|
|
// We already checked whether key exists in mMetricsManagers in
|
|
// WriteDataToDisk.
|
|
auto it = mMetricsManagers.find(key);
|
|
if (it == mMetricsManagers.end()) {
|
|
return;
|
|
}
|
|
int64_t lastReportTimeNs = it->second->getLastReportTimeNs();
|
|
int64_t lastReportWallClockNs = it->second->getLastReportWallClockNs();
|
|
|
|
std::set<string> str_set;
|
|
|
|
// First, fill in ConfigMetricsReport using current data on memory, which
|
|
// starts from filling in StatsLogReport's.
|
|
it->second->onDumpReport(dumpTimeStampNs, include_current_partial_bucket,
|
|
erase_data, &str_set, proto);
|
|
|
|
// Fill in UidMap if there is at least one metric to report.
|
|
// This skips the uid map if it's an empty config.
|
|
if (it->second->getNumMetrics() > 0) {
|
|
uint64_t uidMapToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_ID_UID_MAP);
|
|
mUidMap->appendUidMap(
|
|
dumpTimeStampNs, key, it->second->hashStringInReport() ? &str_set : nullptr,
|
|
it->second->versionStringsInReport(), it->second->installerInReport(), proto);
|
|
proto->end(uidMapToken);
|
|
}
|
|
|
|
// Fill in the timestamps.
|
|
proto->write(FIELD_TYPE_INT64 | FIELD_ID_LAST_REPORT_ELAPSED_NANOS,
|
|
(long long)lastReportTimeNs);
|
|
proto->write(FIELD_TYPE_INT64 | FIELD_ID_CURRENT_REPORT_ELAPSED_NANOS,
|
|
(long long)dumpTimeStampNs);
|
|
proto->write(FIELD_TYPE_INT64 | FIELD_ID_LAST_REPORT_WALL_CLOCK_NANOS,
|
|
(long long)lastReportWallClockNs);
|
|
proto->write(FIELD_TYPE_INT64 | FIELD_ID_CURRENT_REPORT_WALL_CLOCK_NANOS,
|
|
(long long)getWallClockNs());
|
|
// Dump report reason
|
|
proto->write(FIELD_TYPE_INT32 | FIELD_ID_DUMP_REPORT_REASON, dumpReportReason);
|
|
|
|
for (const auto& str : str_set) {
|
|
proto->write(FIELD_TYPE_STRING | FIELD_COUNT_REPEATED | FIELD_ID_STRINGS, str);
|
|
}
|
|
}
|
|
|
|
void StatsLogProcessor::resetConfigsLocked(const int64_t timestampNs,
|
|
const std::vector<ConfigKey>& configs) {
|
|
for (const auto& key : configs) {
|
|
StatsdConfig config;
|
|
if (StorageManager::readConfigFromDisk(key, &config)) {
|
|
OnConfigUpdatedLocked(timestampNs, key, config);
|
|
StatsdStats::getInstance().noteConfigReset(key);
|
|
} else {
|
|
ALOGE("Failed to read backup config from disk for : %s", key.ToString().c_str());
|
|
auto it = mMetricsManagers.find(key);
|
|
if (it != mMetricsManagers.end()) {
|
|
it->second->refreshTtl(timestampNs);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void StatsLogProcessor::resetIfConfigTtlExpiredLocked(const int64_t timestampNs) {
|
|
std::vector<ConfigKey> configKeysTtlExpired;
|
|
for (auto it = mMetricsManagers.begin(); it != mMetricsManagers.end(); it++) {
|
|
if (it->second != nullptr && !it->second->isInTtl(timestampNs)) {
|
|
configKeysTtlExpired.push_back(it->first);
|
|
}
|
|
}
|
|
if (configKeysTtlExpired.size() > 0) {
|
|
WriteDataToDiskLocked(CONFIG_RESET);
|
|
resetConfigsLocked(timestampNs, configKeysTtlExpired);
|
|
}
|
|
}
|
|
|
|
void StatsLogProcessor::OnConfigRemoved(const ConfigKey& key) {
|
|
std::lock_guard<std::mutex> lock(mMetricsMutex);
|
|
auto it = mMetricsManagers.find(key);
|
|
if (it != mMetricsManagers.end()) {
|
|
WriteDataToDiskLocked(key, getElapsedRealtimeNs(), CONFIG_REMOVED);
|
|
mMetricsManagers.erase(it);
|
|
mUidMap->OnConfigRemoved(key);
|
|
}
|
|
StatsdStats::getInstance().noteConfigRemoved(key);
|
|
|
|
mLastBroadcastTimes.erase(key);
|
|
|
|
if (mMetricsManagers.empty()) {
|
|
mPullerManager->ForceClearPullerCache();
|
|
}
|
|
}
|
|
|
|
void StatsLogProcessor::flushIfNecessaryLocked(
|
|
int64_t timestampNs, const ConfigKey& key, MetricsManager& metricsManager) {
|
|
auto lastCheckTime = mLastByteSizeTimes.find(key);
|
|
if (lastCheckTime != mLastByteSizeTimes.end()) {
|
|
if (timestampNs - lastCheckTime->second < StatsdStats::kMinByteSizeCheckPeriodNs) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
// We suspect that the byteSize() computation is expensive, so we set a rate limit.
|
|
size_t totalBytes = metricsManager.byteSize();
|
|
mLastByteSizeTimes[key] = timestampNs;
|
|
bool requestDump = false;
|
|
if (totalBytes >
|
|
StatsdStats::kMaxMetricsBytesPerConfig) { // Too late. We need to start clearing data.
|
|
metricsManager.dropData(timestampNs);
|
|
StatsdStats::getInstance().noteDataDropped(key, totalBytes);
|
|
VLOG("StatsD had to toss out metrics for %s", key.ToString().c_str());
|
|
} else if ((totalBytes > StatsdStats::kBytesPerConfigTriggerGetData) ||
|
|
(mOnDiskDataConfigs.find(key) != mOnDiskDataConfigs.end())) {
|
|
// Request to send a broadcast if:
|
|
// 1. in memory data > threshold OR
|
|
// 2. config has old data report on disk.
|
|
requestDump = true;
|
|
}
|
|
|
|
if (requestDump) {
|
|
// Send broadcast so that receivers can pull data.
|
|
auto lastBroadcastTime = mLastBroadcastTimes.find(key);
|
|
if (lastBroadcastTime != mLastBroadcastTimes.end()) {
|
|
if (timestampNs - lastBroadcastTime->second < StatsdStats::kMinBroadcastPeriodNs) {
|
|
VLOG("StatsD would've sent a broadcast but the rate limit stopped us.");
|
|
return;
|
|
}
|
|
}
|
|
if (mSendBroadcast(key)) {
|
|
mOnDiskDataConfigs.erase(key);
|
|
VLOG("StatsD triggered data fetch for %s", key.ToString().c_str());
|
|
mLastBroadcastTimes[key] = timestampNs;
|
|
StatsdStats::getInstance().noteBroadcastSent(key);
|
|
}
|
|
}
|
|
}
|
|
|
|
void StatsLogProcessor::WriteDataToDiskLocked(const ConfigKey& key,
|
|
const int64_t timestampNs,
|
|
const DumpReportReason dumpReportReason) {
|
|
if (mMetricsManagers.find(key) == mMetricsManagers.end() ||
|
|
!mMetricsManagers.find(key)->second->shouldWriteToDisk()) {
|
|
return;
|
|
}
|
|
ProtoOutputStream proto;
|
|
onConfigMetricsReportLocked(key, timestampNs, true /* include_current_partial_bucket*/,
|
|
true /* erase_data */, dumpReportReason, &proto);
|
|
string file_name = StringPrintf("%s/%ld_%d_%lld", STATS_DATA_DIR,
|
|
(long)getWallClockSec(), key.GetUid(), (long long)key.GetId());
|
|
android::base::unique_fd fd(open(file_name.c_str(),
|
|
O_WRONLY | O_CREAT | O_CLOEXEC, S_IRUSR | S_IWUSR));
|
|
if (fd == -1) {
|
|
ALOGE("Attempt to write %s but failed", file_name.c_str());
|
|
return;
|
|
}
|
|
proto.flush(fd.get());
|
|
// We were able to write the ConfigMetricsReport to disk, so we should trigger collection ASAP.
|
|
mOnDiskDataConfigs.insert(key);
|
|
}
|
|
|
|
void StatsLogProcessor::WriteDataToDiskLocked(const DumpReportReason dumpReportReason) {
|
|
const int64_t timeNs = getElapsedRealtimeNs();
|
|
// Do not write to disk if we already have in the last few seconds.
|
|
// This is to avoid overwriting files that would have the same name if we
|
|
// write twice in the same second.
|
|
if (static_cast<unsigned long long> (timeNs) <
|
|
mLastWriteTimeNs + WRITE_DATA_COOL_DOWN_SEC * NS_PER_SEC) {
|
|
ALOGI("Statsd skipping writing data to disk. Already wrote data in last %d seconds",
|
|
WRITE_DATA_COOL_DOWN_SEC);
|
|
return;
|
|
}
|
|
mLastWriteTimeNs = timeNs;
|
|
for (auto& pair : mMetricsManagers) {
|
|
WriteDataToDiskLocked(pair.first, timeNs, dumpReportReason);
|
|
}
|
|
}
|
|
|
|
void StatsLogProcessor::WriteDataToDisk(const DumpReportReason dumpReportReason) {
|
|
std::lock_guard<std::mutex> lock(mMetricsMutex);
|
|
WriteDataToDiskLocked(dumpReportReason);
|
|
}
|
|
|
|
void StatsLogProcessor::informPullAlarmFired(const int64_t timestampNs) {
|
|
std::lock_guard<std::mutex> lock(mMetricsMutex);
|
|
mPullerManager->OnAlarmFired(timestampNs);
|
|
}
|
|
|
|
int64_t StatsLogProcessor::getLastReportTimeNs(const ConfigKey& key) {
|
|
auto it = mMetricsManagers.find(key);
|
|
if (it == mMetricsManagers.end()) {
|
|
return 0;
|
|
} else {
|
|
return it->second->getLastReportTimeNs();
|
|
}
|
|
}
|
|
|
|
void StatsLogProcessor::noteOnDiskData(const ConfigKey& key) {
|
|
std::lock_guard<std::mutex> lock(mMetricsMutex);
|
|
mOnDiskDataConfigs.insert(key);
|
|
}
|
|
|
|
} // namespace statsd
|
|
} // namespace os
|
|
} // namespace android
|