commit b142cc8add29c8c97f6134d35873d23db666027c
author Yangster-mac <yanglu@google.com> Fri Mar 30 15:22:08 2018 -0700
committer Yang Lu <yanglu@google.com> Wed Apr 04 15:59:43 2018 +0000
tree 84821e80be1a6b2fd9f30d583442bade56f21657
parent a926126a8bc89c1a6bd7fa8a76332476eba0d954

Statsd config TTL

Roughly check the config every hour to see whether the ttl expired.
If so, read the config from disk and recreate the metric manager.

Test: statsd test

BUG: b/77274363

Change-Id: I16838afe5bbe966c3a0f638869751f9b59a5a259

cmds/statsd/src/metrics/MetricProducer.h

diff --git a/cmds/statsd/src/metrics/MetricProducer.h b/cmds/statsd/src/metrics/MetricProducer.h
index 0b3d677..139a407 100644
--- a/cmds/statsd/src/metrics/MetricProducer.h
+++ b/cmds/statsd/src/metrics/MetricProducer.h
@@ -64,7 +64,7 @@
      * the flush again when the end timestamp is forced to be now, and then after flushing, update
      * the start timestamp to be now.
      */
-    void notifyAppUpgrade(const uint64_t& eventTimeNs, const string& apk, const int uid,
+    void notifyAppUpgrade(const int64_t& eventTimeNs, const string& apk, const int uid,
                           const int64_t version) override {
         std::lock_guard<std::mutex> lock(mMutex);
 
@@ -79,11 +79,11 @@
         // is a partial bucket and can merge it with the previous bucket.
     };
 
-    void notifyAppRemoved(const uint64_t& eventTimeNs, const string& apk, const int uid) override{
+    void notifyAppRemoved(const int64_t& eventTimeNs, const string& apk, const int uid) override{
             // TODO: Implement me.
     };
 
-    void onUidMapReceived(const uint64_t& eventTimeNs) override{
+    void onUidMapReceived(const int64_t& eventTimeNs) override{
             // TODO: Implement me.
     };
 
@@ -93,12 +93,12 @@
         onMatchedLogEventLocked(matcherIndex, event);
     }
 
-    void onConditionChanged(const bool condition, const uint64_t eventTime) {
+    void onConditionChanged(const bool condition, const int64_t eventTime) {
         std::lock_guard<std::mutex> lock(mMutex);
         onConditionChangedLocked(condition, eventTime);
     }
 
-    void onSlicedConditionMayChange(bool overallCondition, const uint64_t eventTime) {
+    void onSlicedConditionMayChange(bool overallCondition, const int64_t eventTime) {
         std::lock_guard<std::mutex> lock(mMutex);
         onSlicedConditionMayChangeLocked(overallCondition, eventTime);
     }
@@ -110,7 +110,7 @@
 
     // Output the metrics data to [protoOutput]. All metrics reports end with the same timestamp.
     // This method clears all the past buckets.
-    void onDumpReport(const uint64_t dumpTimeNs, android::util::ProtoOutputStream* protoOutput) {
+    void onDumpReport(const int64_t dumpTimeNs, android::util::ProtoOutputStream* protoOutput) {
         std::lock_guard<std::mutex> lock(mMutex);
         return onDumpReportLocked(dumpTimeNs, protoOutput);
     }
@@ -156,16 +156,16 @@
     // We still need to keep future data valid and anomaly tracking work, which means we will
     // have to flush old data, informing anomaly trackers then safely drop old data.
     // We still keep current bucket data for future metrics' validity.
-    void dropData(const uint64_t dropTimeNs) {
+    void dropData(const int64_t dropTimeNs) {
         std::lock_guard<std::mutex> lock(mMutex);
         dropDataLocked(dropTimeNs);
     }
 
 protected:
-    virtual void onConditionChangedLocked(const bool condition, const uint64_t eventTime) = 0;
+    virtual void onConditionChangedLocked(const bool condition, const int64_t eventTime) = 0;
     virtual void onSlicedConditionMayChangeLocked(bool overallCondition,
-                                                  const uint64_t eventTime) = 0;
-    virtual void onDumpReportLocked(const uint64_t dumpTimeNs,
+                                                  const int64_t eventTime) = 0;
+    virtual void onDumpReportLocked(const int64_t dumpTimeNs,
                                     android::util::ProtoOutputStream* protoOutput) = 0;
     virtual size_t byteSizeLocked() const = 0;
     virtual void dumpStatesLocked(FILE* out, bool verbose) const = 0;
@@ -173,7 +173,7 @@
     /**
      * Flushes the current bucket if the eventTime is after the current bucket's end time.
      */
-    virtual void flushIfNeededLocked(const uint64_t& eventTime){};
+    virtual void flushIfNeededLocked(const int64_t& eventTime){};
 
     /**
      * For metrics that aggregate (ie, every metric producer except for EventMetricProducer),
@@ -185,15 +185,15 @@
      * flushIfNeededLocked or the app upgrade handler; the caller MUST update the bucket timestamp
      * and bucket number as needed.
      */
-    virtual void flushCurrentBucketLocked(const uint64_t& eventTimeNs){};
+    virtual void flushCurrentBucketLocked(const int64_t& eventTimeNs){};
 
     // Convenience to compute the current bucket's end time, which is always aligned with the
     // start time of the metric.
-    uint64_t getCurrentBucketEndTimeNs() const {
+    int64_t getCurrentBucketEndTimeNs() const {
         return mStartTimeNs + (mCurrentBucketNum + 1) * mBucketSizeNs;
     }
 
-    virtual void dropDataLocked(const uint64_t dropTimeNs) = 0;
+    virtual void dropDataLocked(const int64_t dropTimeNs) = 0;
 
     const int64_t mMetricId;
 
@@ -201,15 +201,15 @@
 
     // The time when this metric producer was first created. The end time for the current bucket
     // can be computed from this based on mCurrentBucketNum.
-    uint64_t mStartTimeNs;
+    int64_t mStartTimeNs;
 
     // Start time may not be aligned with the start of statsd if there is an app upgrade in the
     // middle of a bucket.
-    uint64_t mCurrentBucketStartTimeNs;
+    int64_t mCurrentBucketStartTimeNs;
 
     // Used by anomaly detector to track which bucket we are in. This is not sent with the produced
     // report.
-    uint64_t mCurrentBucketNum;
+    int64_t mCurrentBucketNum;
 
     int64_t mBucketSizeNs;