Merge "Merge changes Icd1b1e57,Ib9c6b9b4 into rvc-dev am: 898dda3919 am:... (fb79a590) · Commits · e / os / android_frameworks_base

cmds/statsd/Android.bp

+2 −0

Original line number	Diff line number	Diff line
		@@ -78,6 +78,7 @@ cc_defaults {
		"src/matchers/EventMatcherWizard.cpp",
		"src/matchers/matcher_util.cpp",
		"src/matchers/SimpleLogMatchingTracker.cpp",
		"src/metadata_util.cpp",
		"src/metrics/CountMetricProducer.cpp",
		"src/metrics/duration_helper/MaxDurationTracker.cpp",
		"src/metrics/duration_helper/OringDurationTracker.cpp",
		@@ -340,6 +341,7 @@ cc_test {
		"tests/log_event/LogEventQueue_test.cpp",
		"tests/LogEntryMatcher_test.cpp",
		"tests/LogEvent_test.cpp",
		"tests/metadata_util_test.cpp",
		"tests/metrics/CountMetricProducer_test.cpp",
		"tests/metrics/DurationMetricProducer_test.cpp",
		"tests/metrics/EventMetricProducer_test.cpp",

cmds/statsd/src/StatsLogProcessor.cpp

+105 −0

Original line number	Diff line number	Diff line
		@@ -79,6 +79,7 @@ constexpr const char* kPermissionUsage = "android.permission.PACKAGE_USAGE_STATS
		#define NS_PER_HOUR 3600 * NS_PER_SEC

		#define STATS_ACTIVE_METRIC_DIR "/data/misc/stats-active-metric"
		#define STATS_METADATA_DIR "/data/misc/stats-metadata"

		// Cool down period for writing data to disk to avoid overwriting files.
		#define WRITE_DATA_COOL_DOWN_SEC 5
		@@ -852,6 +853,110 @@ void StatsLogProcessor::SaveActiveConfigsToDisk(int64_t currentTimeNs) {
		proto.flush(fd.get());
		}

		void StatsLogProcessor::SaveMetadataToDisk(int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs) {
		std::lock_guard<std::mutex> lock(mMetricsMutex);
		// Do not write to disk if we already have in the last few seconds.
		if (static_cast<unsigned long long> (systemElapsedTimeNs) <
		mLastMetadataWriteNs + WRITE_DATA_COOL_DOWN_SEC * NS_PER_SEC) {
		ALOGI("Statsd skipping writing metadata to disk. Already wrote data in last %d seconds",
		WRITE_DATA_COOL_DOWN_SEC);
		return;
		}
		mLastMetadataWriteNs = systemElapsedTimeNs;

		metadata::StatsMetadataList metadataList;
		WriteMetadataToProtoLocked(
		currentWallClockTimeNs, systemElapsedTimeNs, &metadataList);

		string file_name = StringPrintf("%s/metadata", STATS_METADATA_DIR);
		StorageManager::deleteFile(file_name.c_str());

		if (metadataList.stats_metadata_size() == 0) {
		// Skip the write if we have nothing to write.
		return;
		}

		std::string data;
		metadataList.SerializeToString(&data);
		StorageManager::writeFile(file_name.c_str(), data.c_str(), data.size());
		}

		void StatsLogProcessor::WriteMetadataToProto(int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs,
		metadata::StatsMetadataList* metadataList) {
		std::lock_guard<std::mutex> lock(mMetricsMutex);
		WriteMetadataToProtoLocked(currentWallClockTimeNs, systemElapsedTimeNs, metadataList);
		}

		void StatsLogProcessor::WriteMetadataToProtoLocked(int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs,
		metadata::StatsMetadataList* metadataList) {
		for (const auto& pair : mMetricsManagers) {
		const sp<MetricsManager>& metricsManager = pair.second;
		metadata::StatsMetadata* statsMetadata = metadataList->add_stats_metadata();
		bool metadataWritten = metricsManager->writeMetadataToProto(currentWallClockTimeNs,
		systemElapsedTimeNs, statsMetadata);
		if (!metadataWritten) {
		metadataList->mutable_stats_metadata()->RemoveLast();
		}
		}
		}

		void StatsLogProcessor::LoadMetadataFromDisk(int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs) {
		std::lock_guard<std::mutex> lock(mMetricsMutex);
		string file_name = StringPrintf("%s/metadata", STATS_METADATA_DIR);
		int fd = open(file_name.c_str(), O_RDONLY \| O_CLOEXEC);
		if (-1 == fd) {
		VLOG("Attempt to read %s but failed", file_name.c_str());
		StorageManager::deleteFile(file_name.c_str());
		return;
		}
		string content;
		if (!android::base::ReadFdToString(fd, &content)) {
		ALOGE("Attempt to read %s but failed", file_name.c_str());
		close(fd);
		StorageManager::deleteFile(file_name.c_str());
		return;
		}

		close(fd);

		metadata::StatsMetadataList statsMetadataList;
		if (!statsMetadataList.ParseFromString(content)) {
		ALOGE("Attempt to read %s but failed; failed to metadata", file_name.c_str());
		StorageManager::deleteFile(file_name.c_str());
		return;
		}
		SetMetadataStateLocked(statsMetadataList, currentWallClockTimeNs, systemElapsedTimeNs);
		StorageManager::deleteFile(file_name.c_str());
		}

		void StatsLogProcessor::SetMetadataState(const metadata::StatsMetadataList& statsMetadataList,
		int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs) {
		std::lock_guard<std::mutex> lock(mMetricsMutex);
		SetMetadataStateLocked(statsMetadataList, currentWallClockTimeNs, systemElapsedTimeNs);
		}

		void StatsLogProcessor::SetMetadataStateLocked(
		const metadata::StatsMetadataList& statsMetadataList,
		int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs) {
		for (const metadata::StatsMetadata& metadata : statsMetadataList.stats_metadata()) {
		ConfigKey key(metadata.config_key().uid(), metadata.config_key().config_id());
		auto it = mMetricsManagers.find(key);
		if (it == mMetricsManagers.end()) {
		ALOGE("No config found for configKey %s", key.ToString().c_str());
		continue;
		}
		VLOG("Setting metadata %s", key.ToString().c_str());
		it->second->loadMetadata(metadata, currentWallClockTimeNs, systemElapsedTimeNs);
		}
		VLOG("Successfully loaded %d metadata.", statsMetadataList.stats_metadata_size());
		}

		void StatsLogProcessor::WriteActiveConfigsToProtoOutputStream(
		int64_t currentTimeNs, const DumpReportReason reason, ProtoOutputStream* proto) {
		std::lock_guard<std::mutex> lock(mMetricsMutex);

cmds/statsd/src/StatsLogProcessor.h

+33 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@
		#include "external/StatsPullerManager.h"

		#include "frameworks/base/cmds/statsd/src/statsd_config.pb.h"
		#include "frameworks/base/cmds/statsd/src/statsd_metadata.pb.h"

		#include <stdio.h>
		#include <unordered_map>
		@@ -89,6 +90,23 @@ public:
		/* Load configs containing metrics with active activations from disk. */
		void LoadActiveConfigsFromDisk();

		/* Persist metadata for configs and metrics to disk. */
		void SaveMetadataToDisk(int64_t currentWallClockTimeNs, int64_t systemElapsedTimeNs);

		/* Writes the statsd metadata for all configs and metrics to StatsMetadataList. */
		void WriteMetadataToProto(int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs,
		metadata::StatsMetadataList* metadataList);

		/* Load stats metadata for configs and metrics from disk. */
		void LoadMetadataFromDisk(int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs);

		/* Sets the metadata for all configs and metrics */
		void SetMetadataState(const metadata::StatsMetadataList& statsMetadataList,
		int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs);

		/* Sets the active status/ttl for all configs and metrics to the status in ActiveConfigList. */
		void SetConfigsActiveState(const ActiveConfigList& activeConfigList, int64_t currentTimeNs);

		@@ -173,8 +191,17 @@ private:
		void SetConfigsActiveStateLocked(const ActiveConfigList& activeConfigList,
		int64_t currentTimeNs);

		void SetMetadataStateLocked(const metadata::StatsMetadataList& statsMetadataList,
		int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs);

		void WriteMetadataToProtoLocked(int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs,
		metadata::StatsMetadataList* metadataList);

		void WriteDataToDiskLocked(const DumpReportReason dumpReportReason,
		const DumpLatency dumpLatency);

		void WriteDataToDiskLocked(const ConfigKey& key, const int64_t timestampNs,
		const DumpReportReason dumpReportReason,
		const DumpLatency dumpLatency);
		@@ -241,6 +268,9 @@ private:
		// Last time we wrote active metrics to disk.
		int64_t mLastActiveMetricsWriteNs = 0;

		//Last time we wrote metadata to disk.
		int64_t mLastMetadataWriteNs = 0;

		#ifdef VERY_VERBOSE_PRINTING
		bool mPrintAllLogs = false;
		#endif
		@@ -278,6 +308,9 @@ private:

		FRIEND_TEST(AnomalyDetectionE2eTest, TestSlicedCountMetric_single_bucket);
		FRIEND_TEST(AnomalyDetectionE2eTest, TestSlicedCountMetric_multiple_buckets);
		FRIEND_TEST(AnomalyDetectionE2eTest, TestCountMetric_save_refractory_to_disk_no_data_written);
		FRIEND_TEST(AnomalyDetectionE2eTest, TestCountMetric_save_refractory_to_disk);
		FRIEND_TEST(AnomalyDetectionE2eTest, TestCountMetric_load_refractory_from_disk);
		FRIEND_TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_single_bucket);
		FRIEND_TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_multiple_buckets);
		FRIEND_TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_long_refractory_period);

cmds/statsd/src/StatsService.cpp

+10 −4

Original line number	Diff line number	Diff line
		@@ -1022,6 +1022,7 @@ Status StatsService::informDeviceShutdown() {
		VLOG("StatsService::informDeviceShutdown");
		mProcessor->WriteDataToDisk(DEVICE_SHUTDOWN, FAST);
		mProcessor->SaveActiveConfigsToDisk(getElapsedRealtimeNs());
		mProcessor->SaveMetadataToDisk(getWallClockNs(), getElapsedRealtimeNs());
		return Status::ok();
		}

		@@ -1056,6 +1057,7 @@ Status StatsService::statsCompanionReady() {
		void StatsService::Startup() {
		mConfigManager->Startup();
		mProcessor->LoadActiveConfigsFromDisk();
		mProcessor->LoadMetadataFromDisk(getWallClockNs(), getElapsedRealtimeNs());
		}

		void StatsService::Terminate() {
		@@ -1063,6 +1065,7 @@ void StatsService::Terminate() {
		if (mProcessor != nullptr) {
		mProcessor->WriteDataToDisk(TERMINATION_SIGNAL_RECEIVED, FAST);
		mProcessor->SaveActiveConfigsToDisk(getElapsedRealtimeNs());
		mProcessor->SaveMetadataToDisk(getWallClockNs(), getElapsedRealtimeNs());
		}
		}

		@@ -1285,20 +1288,23 @@ void StatsService::statsCompanionServiceDiedImpl() {
		if (mProcessor != nullptr) {
		ALOGW("Reset statsd upon system server restarts.");
		int64_t systemServerRestartNs = getElapsedRealtimeNs();
		ProtoOutputStream proto;
		ProtoOutputStream activeConfigsProto;
		mProcessor->WriteActiveConfigsToProtoOutputStream(systemServerRestartNs,
		STATSCOMPANION_DIED, &proto);

		STATSCOMPANION_DIED, &activeConfigsProto);
		metadata::StatsMetadataList metadataList;
		mProcessor->WriteMetadataToProto(getWallClockNs(),
		systemServerRestartNs, &metadataList);
		mProcessor->WriteDataToDisk(STATSCOMPANION_DIED, FAST);
		mProcessor->resetConfigs();

		std::string serializedActiveConfigs;
		if (proto.serializeToString(&serializedActiveConfigs)) {
		if (activeConfigsProto.serializeToString(&serializedActiveConfigs)) {
		ActiveConfigList activeConfigs;
		if (activeConfigs.ParseFromString(serializedActiveConfigs)) {
		mProcessor->SetConfigsActiveState(activeConfigs, systemServerRestartNs);
		}
		}
		mProcessor->SetMetadataState(metadataList, getWallClockNs(), systemServerRestartNs);
		}
		mAnomalyAlarmMonitor->setStatsCompanionService(nullptr);
		mPeriodicAlarmMonitor->setStatsCompanionService(nullptr);

cmds/statsd/src/anomaly/AnomalyTracker.cpp

+55 −1

Original line number	Diff line number	Diff line
		@@ -18,9 +18,11 @@
		#include "Log.h"

		#include "AnomalyTracker.h"
		#include "subscriber_util.h"
		#include "external/Perfetto.h"
		#include "guardrail/StatsdStats.h"
		#include "metadata_util.h"
		#include "stats_log_util.h"
		#include "subscriber_util.h"
		#include "subscriber/IncidentdReporter.h"
		#include "subscriber/SubscriberReporter.h"

		@@ -262,6 +264,58 @@ void AnomalyTracker::informSubscribers(const MetricDimensionKey& key, int64_t me
		triggerSubscribers(mAlert.id(), metric_id, key, metricValue, mConfigKey, mSubscriptions);
		}

		bool AnomalyTracker::writeAlertMetadataToProto(int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs,
		metadata::AlertMetadata* alertMetadata) {
		bool metadataWritten = false;

		if (mRefractoryPeriodEndsSec.empty()) {
		return false;
		}

		for (const auto& it: mRefractoryPeriodEndsSec) {
		// Do not write the timestamp to disk if it has already expired
		if (it.second < systemElapsedTimeNs / NS_PER_SEC) {
		continue;
		}

		metadataWritten = true;
		if (alertMetadata->alert_dim_keyed_data_size() == 0) {
		alertMetadata->set_alert_id(mAlert.id());
		}

		metadata::AlertDimensionKeyedData* keyedData = alertMetadata->add_alert_dim_keyed_data();
		// We convert and write the refractory_end_sec to wall clock time because we do not know
		// when statsd will start again.
		int32_t refractoryEndWallClockSec = (int32_t) ((currentWallClockTimeNs / NS_PER_SEC) +
		(it.second - systemElapsedTimeNs / NS_PER_SEC));

		keyedData->set_last_refractory_ends_sec(refractoryEndWallClockSec);
		writeMetricDimensionKeyToMetadataDimensionKey(
		it.first, keyedData->mutable_dimension_key());
		}

		return metadataWritten;
		}

		void AnomalyTracker::loadAlertMetadata(
		const metadata::AlertMetadata& alertMetadata,
		int64_t currentWallClockTimeNs,
		int64_t systemElapsedTimeNs) {
		for (const metadata::AlertDimensionKeyedData& keyedData :
		alertMetadata.alert_dim_keyed_data()) {
		if ((uint64_t) keyedData.last_refractory_ends_sec() < currentWallClockTimeNs / NS_PER_SEC) {
		// Do not update the timestamp if it has already expired.
		continue;
		}
		MetricDimensionKey metricKey = loadMetricDimensionKeyFromProto(
		keyedData.dimension_key());
		int32_t refractoryPeriodEndsSec = (int32_t) keyedData.last_refractory_ends_sec() -
		currentWallClockTimeNs / NS_PER_SEC + systemElapsedTimeNs / NS_PER_SEC;
		mRefractoryPeriodEndsSec[metricKey] = refractoryPeriodEndsSec;
		}
		}

		} // namespace statsd
		} // namespace os
		} // namespace android