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

Commit b5d5fedc authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Perform partial update for gauge metric"

parents 59bbb422 26943095
Loading
Loading
Loading
Loading
+56 −2
Original line number Diff line number Diff line
@@ -17,9 +17,11 @@
#define DEBUG false  // STOPSHIP if true
#include "Log.h"

#include "../guardrail/StatsdStats.h"
#include "GaugeMetricProducer.h"
#include "../stats_log_util.h"

#include "guardrail/StatsdStats.h"
#include "metrics/parsing_utils/metrics_manager_util.h"
#include "stats_log_util.h"

using android::util::FIELD_COUNT_REPEATED;
using android::util::FIELD_TYPE_BOOL;
@@ -154,6 +156,58 @@ GaugeMetricProducer::~GaugeMetricProducer() {
    }
}

bool GaugeMetricProducer::onConfigUpdatedLocked(
        const StatsdConfig& config, const int configIndex, const int metricIndex,
        const vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers,
        const unordered_map<int64_t, int>& oldAtomMatchingTrackerMap,
        const unordered_map<int64_t, int>& newAtomMatchingTrackerMap,
        const sp<EventMatcherWizard>& matcherWizard,
        const vector<sp<ConditionTracker>>& allConditionTrackers,
        const unordered_map<int64_t, int>& conditionTrackerMap, const sp<ConditionWizard>& wizard,
        const unordered_map<int64_t, int>& metricToActivationMap,
        unordered_map<int, vector<int>>& trackerToMetricMap,
        unordered_map<int, vector<int>>& conditionToMetricMap,
        unordered_map<int, vector<int>>& activationAtomTrackerToMetricMap,
        unordered_map<int, vector<int>>& deactivationAtomTrackerToMetricMap,
        vector<int>& metricsWithActivation) {
    if (!MetricProducer::onConfigUpdatedLocked(
                config, configIndex, metricIndex, allAtomMatchingTrackers,
                oldAtomMatchingTrackerMap, newAtomMatchingTrackerMap, matcherWizard,
                allConditionTrackers, conditionTrackerMap, wizard, metricToActivationMap,
                trackerToMetricMap, conditionToMetricMap, activationAtomTrackerToMetricMap,
                deactivationAtomTrackerToMetricMap, metricsWithActivation)) {
        return false;
    }

    const GaugeMetric& metric = config.gauge_metric(configIndex);
    // Update appropriate indices: mWhatMatcherIndex, mConditionIndex and MetricsManager maps.
    if (!handleMetricWithAtomMatchingTrackers(metric.what(), metricIndex, /*enforceOneAtom=*/false,
                                              allAtomMatchingTrackers, newAtomMatchingTrackerMap,
                                              trackerToMetricMap, mWhatMatcherIndex)) {
        return false;
    }

    // Need to update maps since the index changed, but mTriggerAtomId will not change.
    int triggerTrackerIndex;
    if (metric.has_trigger_event() &&
        !handleMetricWithAtomMatchingTrackers(metric.trigger_event(), metricIndex,
                                              /*enforceOneAtom=*/true, allAtomMatchingTrackers,
                                              newAtomMatchingTrackerMap, trackerToMetricMap,
                                              triggerTrackerIndex)) {
        return false;
    }

    if (metric.has_condition() &&
        !handleMetricWithConditions(metric.condition(), metricIndex, conditionTrackerMap,
                                    metric.links(), allConditionTrackers, mConditionTrackerIndex,
                                    conditionToMetricMap)) {
        return false;
    }
    sp<EventMatcherWizard> tmpEventWizard = mEventMatcherWizard;
    mEventMatcherWizard = matcherWizard;
    return true;
}

void GaugeMetricProducer::dumpStatesLocked(FILE* out, bool verbose) const {
    if (mCurrentSlicedBucket == nullptr ||
        mCurrentSlicedBucket->size() == 0) {
+21 −3
Original line number Diff line number Diff line
@@ -53,8 +53,8 @@ typedef std::unordered_map<MetricDimensionKey, std::vector<GaugeAtom>>
// This gauge metric producer first register the puller to automatically pull the gauge at the
// beginning of each bucket. If the condition is met, insert it to the bucket info. Otherwise
// proactively pull the gauge when the condition is changed to be true. Therefore, the gauge metric
// producer always reports the guage at the earliest time of the bucket when the condition is met.
class GaugeMetricProducer : public virtual MetricProducer, public virtual PullDataReceiver {
// producer always reports the gauge at the earliest time of the bucket when the condition is met.
class GaugeMetricProducer : public MetricProducer, public virtual PullDataReceiver {
public:
    GaugeMetricProducer(
            const ConfigKey& key, const GaugeMetric& gaugeMetric, const int conditionIndex,
@@ -142,7 +142,23 @@ private:

    void pullAndMatchEventsLocked(const int64_t timestampNs);

    const int mWhatMatcherIndex;
    bool onConfigUpdatedLocked(
            const StatsdConfig& config, const int configIndex, const int metricIndex,
            const std::vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers,
            const std::unordered_map<int64_t, int>& oldAtomMatchingTrackerMap,
            const std::unordered_map<int64_t, int>& newAtomMatchingTrackerMap,
            const sp<EventMatcherWizard>& matcherWizard,
            const std::vector<sp<ConditionTracker>>& allConditionTrackers,
            const std::unordered_map<int64_t, int>& conditionTrackerMap,
            const sp<ConditionWizard>& wizard,
            const std::unordered_map<int64_t, int>& metricToActivationMap,
            std::unordered_map<int, std::vector<int>>& trackerToMetricMap,
            std::unordered_map<int, std::vector<int>>& conditionToMetricMap,
            std::unordered_map<int, std::vector<int>>& activationAtomTrackerToMetricMap,
            std::unordered_map<int, std::vector<int>>& deactivationAtomTrackerToMetricMap,
            std::vector<int>& metricsWithActivation) override;

    int mWhatMatcherIndex;

    sp<EventMatcherWizard> mEventMatcherWizard;

@@ -209,6 +225,8 @@ private:

    FRIEND_TEST(GaugeMetricProducerTest_PartialBucket, TestPushedEvents);
    FRIEND_TEST(GaugeMetricProducerTest_PartialBucket, TestPulled);

    FRIEND_TEST(ConfigUpdateTest, TestUpdateGaugeMetrics);
};

}  // namespace statsd
+1 −0
Original line number Diff line number Diff line
@@ -568,6 +568,7 @@ protected:
    FRIEND_TEST(ConfigUpdateTest, TestUpdateMetricActivations);
    FRIEND_TEST(ConfigUpdateTest, TestUpdateCountMetrics);
    FRIEND_TEST(ConfigUpdateTest, TestUpdateEventMetrics);
    FRIEND_TEST(ConfigUpdateTest, TestUpdateGaugeMetrics);
    FRIEND_TEST(ConfigUpdateTest, TestUpdateMetricsMultipleTypes);
};

+99 −40
Original line number Diff line number Diff line
@@ -556,6 +556,44 @@ bool determineAllMetricUpdateStatuses(const StatsdConfig& config,
    return true;
}

// Called when a metric is preserved during a config update. Finds the metric in oldMetricProducers
// and calls onConfigUpdated to update all indices.
optional<sp<MetricProducer>> updateMetric(
        const StatsdConfig& config, const int configIndex, const int metricIndex,
        const int64_t metricId, const vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers,
        const unordered_map<int64_t, int>& oldAtomMatchingTrackerMap,
        const unordered_map<int64_t, int>& newAtomMatchingTrackerMap,
        const sp<EventMatcherWizard>& matcherWizard,
        const vector<sp<ConditionTracker>>& allConditionTrackers,
        const unordered_map<int64_t, int>& conditionTrackerMap, const sp<ConditionWizard>& wizard,
        const unordered_map<int64_t, int>& oldMetricProducerMap,
        const vector<sp<MetricProducer>>& oldMetricProducers,
        const unordered_map<int64_t, int>& metricToActivationMap,
        unordered_map<int, vector<int>>& trackerToMetricMap,
        unordered_map<int, vector<int>>& conditionToMetricMap,
        unordered_map<int, vector<int>>& activationAtomTrackerToMetricMap,
        unordered_map<int, vector<int>>& deactivationAtomTrackerToMetricMap,
        vector<int>& metricsWithActivation) {
    const auto& oldMetricProducerIt = oldMetricProducerMap.find(metricId);
    if (oldMetricProducerIt == oldMetricProducerMap.end()) {
        ALOGE("Could not find Metric %lld in the previous config, but expected it "
              "to be there",
              (long long)metricId);
        return nullopt;
    }
    const int oldIndex = oldMetricProducerIt->second;
    sp<MetricProducer> producer = oldMetricProducers[oldIndex];
    if (!producer->onConfigUpdated(config, configIndex, metricIndex, allAtomMatchingTrackers,
                                   oldAtomMatchingTrackerMap, newAtomMatchingTrackerMap,
                                   matcherWizard, allConditionTrackers, conditionTrackerMap, wizard,
                                   metricToActivationMap, trackerToMetricMap, conditionToMetricMap,
                                   activationAtomTrackerToMetricMap,
                                   deactivationAtomTrackerToMetricMap, metricsWithActivation)) {
        return nullopt;
    }
    return {producer};
}

bool updateMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t timeBaseNs,
                   const int64_t currentTimeNs, const sp<StatsPullerManager>& pullerManager,
                   const unordered_map<int64_t, int>& oldAtomMatchingTrackerMap,
@@ -609,41 +647,29 @@ bool updateMetrics(const ConfigKey& key, const StatsdConfig& config, const int64
    // Now, perform the update. Must iterate the metric types in the same order
    int metricIndex = 0;
    for (int i = 0; i < config.count_metric_size(); i++, metricIndex++) {
        newMetricProducerMap[config.count_metric(i).id()] = metricIndex;
        const CountMetric& metric = config.count_metric(i);
        newMetricProducerMap[metric.id()] = metricIndex;
        optional<sp<MetricProducer>> producer;
        switch (metricsToUpdate[metricIndex]) {
            case UPDATE_PRESERVE: {
                const auto& oldMetricProducerIt = oldMetricProducerMap.find(metric.id());
                if (oldMetricProducerIt == oldMetricProducerMap.end()) {
                    ALOGE("Could not find Metric %lld in the previous config, but expected it "
                          "to be there",
                          (long long)metric.id());
                    return false;
                }
                const int oldIndex = oldMetricProducerIt->second;
                sp<MetricProducer> producer = oldMetricProducers[oldIndex];
                producer->onConfigUpdated(
                        config, i, metricIndex, allAtomMatchingTrackers, oldAtomMatchingTrackerMap,
                        newAtomMatchingTrackerMap, matcherWizard, allConditionTrackers,
                        conditionTrackerMap, wizard, metricToActivationMap, trackerToMetricMap,
                producer = updateMetric(
                        config, i, metricIndex, metric.id(), allAtomMatchingTrackers,
                        oldAtomMatchingTrackerMap, newAtomMatchingTrackerMap, matcherWizard,
                        allConditionTrackers, conditionTrackerMap, wizard, oldMetricProducerMap,
                        oldMetricProducers, metricToActivationMap, trackerToMetricMap,
                        conditionToMetricMap, activationAtomTrackerToMetricMap,
                        deactivationAtomTrackerToMetricMap, metricsWithActivation);
                newMetricProducers.push_back(producer);
                break;
            }
            case UPDATE_REPLACE:
            case UPDATE_NEW: {
                sp<MetricProducer> producer = createCountMetricProducerAndUpdateMetadata(
                producer = createCountMetricProducerAndUpdateMetadata(
                        key, config, timeBaseNs, currentTimeNs, metric, metricIndex,
                        allAtomMatchingTrackers, newAtomMatchingTrackerMap, allConditionTrackers,
                        conditionTrackerMap, initialConditionCache, wizard, stateAtomIdMap,
                        allStateGroupMaps, metricToActivationMap, trackerToMetricMap,
                        conditionToMetricMap, activationAtomTrackerToMetricMap,
                        deactivationAtomTrackerToMetricMap, metricsWithActivation);
                if (producer == nullptr) {
                    return false;
                }
                newMetricProducers.push_back(producer);
                break;
            }
            default: {
@@ -652,42 +678,71 @@ bool updateMetrics(const ConfigKey& key, const StatsdConfig& config, const int64
                return false;
            }
        }
        if (!producer) {
            return false;
        }
        newMetricProducers.push_back(producer.value());
    }
    for (int i = 0; i < config.event_metric_size(); i++, metricIndex++) {
        newMetricProducerMap[config.event_metric(i).id()] = metricIndex;
        const EventMetric& metric = config.event_metric(i);
        optional<sp<MetricProducer>> producer;
        switch (metricsToUpdate[metricIndex]) {
            case UPDATE_PRESERVE: {
                const auto& oldMetricProducerIt = oldMetricProducerMap.find(metric.id());
                if (oldMetricProducerIt == oldMetricProducerMap.end()) {
                    ALOGE("Could not find Metric %lld in the previous config, but expected it "
                          "to be there",
                          (long long)metric.id());
                    return false;
                }
                const int oldIndex = oldMetricProducerIt->second;
                sp<MetricProducer> producer = oldMetricProducers[oldIndex];
                producer->onConfigUpdated(
                        config, i, metricIndex, allAtomMatchingTrackers, oldAtomMatchingTrackerMap,
                        newAtomMatchingTrackerMap, matcherWizard, allConditionTrackers,
                        conditionTrackerMap, wizard, metricToActivationMap, trackerToMetricMap,
                producer = updateMetric(
                        config, i, metricIndex, metric.id(), allAtomMatchingTrackers,
                        oldAtomMatchingTrackerMap, newAtomMatchingTrackerMap, matcherWizard,
                        allConditionTrackers, conditionTrackerMap, wizard, oldMetricProducerMap,
                        oldMetricProducers, metricToActivationMap, trackerToMetricMap,
                        conditionToMetricMap, activationAtomTrackerToMetricMap,
                        deactivationAtomTrackerToMetricMap, metricsWithActivation);
                newMetricProducers.push_back(producer);
                break;
            }
            case UPDATE_REPLACE:
            case UPDATE_NEW: {
                sp<MetricProducer> producer = createEventMetricProducerAndUpdateMetadata(
                producer = createEventMetricProducerAndUpdateMetadata(
                        key, config, timeBaseNs, metric, metricIndex, allAtomMatchingTrackers,
                        newAtomMatchingTrackerMap, allConditionTrackers, conditionTrackerMap,
                        initialConditionCache, wizard, metricToActivationMap, trackerToMetricMap,
                        conditionToMetricMap, activationAtomTrackerToMetricMap,
                        deactivationAtomTrackerToMetricMap, metricsWithActivation);
                if (producer == nullptr) {
                break;
            }
            default: {
                ALOGE("Metric \"%lld\" update state is unknown. This should never happen",
                      (long long)metric.id());
                return false;
            }
                newMetricProducers.push_back(producer);
        }
        if (!producer) {
            return false;
        }
        newMetricProducers.push_back(producer.value());
    }
    for (int i = 0; i < config.gauge_metric_size(); i++, metricIndex++) {
        const GaugeMetric& metric = config.gauge_metric(i);
        newMetricProducerMap[metric.id()] = metricIndex;
        optional<sp<MetricProducer>> producer;
        switch (metricsToUpdate[metricIndex]) {
            case UPDATE_PRESERVE: {
                producer = updateMetric(
                        config, i, metricIndex, metric.id(), allAtomMatchingTrackers,
                        oldAtomMatchingTrackerMap, newAtomMatchingTrackerMap, matcherWizard,
                        allConditionTrackers, conditionTrackerMap, wizard, oldMetricProducerMap,
                        oldMetricProducers, metricToActivationMap, trackerToMetricMap,
                        conditionToMetricMap, activationAtomTrackerToMetricMap,
                        deactivationAtomTrackerToMetricMap, metricsWithActivation);
                break;
            }
            case UPDATE_REPLACE:
            case UPDATE_NEW: {
                producer = createGaugeMetricProducerAndUpdateMetadata(
                        key, config, timeBaseNs, currentTimeNs, pullerManager, metric, metricIndex,
                        allAtomMatchingTrackers, newAtomMatchingTrackerMap, allConditionTrackers,
                        conditionTrackerMap, initialConditionCache, wizard, matcherWizard,
                        metricToActivationMap, trackerToMetricMap, conditionToMetricMap,
                        activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap,
                        metricsWithActivation);
                break;
            }
            default: {
@@ -696,8 +751,12 @@ bool updateMetrics(const ConfigKey& key, const StatsdConfig& config, const int64
                return false;
            }
        }
        if (!producer) {
            return false;
        }
        newMetricProducers.push_back(producer.value());
    }
    // TODO: perform update for count, gauge, value, duration metric.
    // TODO: perform update for value, duration metric.

    const set<int> atomsAllowedFromAnyUid(config.whitelisted_atom_ids().begin(),
                                          config.whitelisted_atom_ids().end());
+149 −120

File changed.

Preview size limit exceeded, changes collapsed.

Loading