Home | History | Annotate | Download | only in external 
      1 /*
      2  * Copyright (C) 2017 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 #pragma once
     18 
     19 #include <android/os/IStatsCompanionService.h>
     20 #include <android/os/IStatsPullerCallback.h>
     21 #include <binder/IServiceManager.h>
     22 #include <utils/RefBase.h>
     23 #include <utils/threads.h>
     24 #include <list>
     25 #include <string>
     26 #include <unordered_map>
     27 #include <vector>
     28 #include "PullDataReceiver.h"
     29 #include "StatsPuller.h"
     30 #include "guardrail/StatsdStats.h"
     31 #include "logd/LogEvent.h"
     32 
     33 namespace android {
     34 namespace os {
     35 namespace statsd {
     36 
     37 typedef struct {
     38     // The field numbers of the fields that need to be summed when merging
     39     // isolated uid with host uid.
     40     std::vector<int> additiveFields;
     41     // Minimum time before this puller does actual pull again.
     42     // Pullers can cause significant impact to system health and battery.
     43     // So that we don't pull too frequently.
     44     // If a pull request comes before cooldown, a cached version from previous pull
     45     // will be returned.
     46     int64_t coolDownNs = 1 * NS_PER_SEC;
     47     // The actual puller
     48     sp<StatsPuller> puller;
     49     // Max time allowed to pull this atom.
     50     // We cannot reliably kill a pull thread. So we don't terminate the puller.
     51     // The data is discarded if the pull takes longer than this and mHasGoodData
     52     // marked as false.
     53     int64_t pullTimeoutNs = StatsdStats::kPullMaxDelayNs;
     54 } PullAtomInfo;
     55 
     56 class StatsPullerManager : public virtual RefBase {
     57 public:
     58     StatsPullerManager();
     59 
     60     virtual ~StatsPullerManager() {
     61     }
     62 
     63     // Registers a receiver for tagId. It will be pulled on the nextPullTimeNs
     64     // and then every intervalNs thereafter.
     65     virtual void RegisterReceiver(int tagId, wp<PullDataReceiver> receiver, int64_t nextPullTimeNs,
     66                                   int64_t intervalNs);
     67 
     68     // Stop listening on a tagId.
     69     virtual void UnRegisterReceiver(int tagId, wp<PullDataReceiver> receiver);
     70 
     71     // Verify if we know how to pull for this matcher
     72     bool PullerForMatcherExists(int tagId) const;
     73 
     74     void OnAlarmFired(int64_t elapsedTimeNs);
     75 
     76     // Pulls the most recent data.
     77     // The data may be served from cache if consecutive pulls come within
     78     // mCoolDownNs.
     79     // Returns true if the pull was successful.
     80     // Returns false when
     81     //   1) the pull fails
     82     //   2) pull takes longer than mPullTimeoutNs (intrinsic to puller)
     83     // If the metric wants to make any change to the data, like timestamps, they
     84     // should make a copy as this data may be shared with multiple metrics.
     85     virtual bool Pull(int tagId, vector<std::shared_ptr<LogEvent>>* data);
     86 
     87     // Clear pull data cache immediately.
     88     int ForceClearPullerCache();
     89 
     90     // Clear pull data cache if it is beyond respective cool down time.
     91     int ClearPullerCacheIfNecessary(int64_t timestampNs);
     92 
     93     void SetStatsCompanionService(sp<IStatsCompanionService> statsCompanionService);
     94 
     95     void RegisterPullerCallback(int32_t atomTag,
     96                                 const sp<IStatsPullerCallback>& callback);
     97 
     98     void UnregisterPullerCallback(int32_t atomTag);
     99 
    100     static std::map<int, PullAtomInfo> kAllPullAtomInfo;
    101 
    102 private:
    103     sp<IStatsCompanionService> mStatsCompanionService = nullptr;
    104 
    105     typedef struct {
    106         int64_t nextPullTimeNs;
    107         int64_t intervalNs;
    108         wp<PullDataReceiver> receiver;
    109     } ReceiverInfo;
    110 
    111     // mapping from simple matcher tagId to receivers
    112     std::map<int, std::list<ReceiverInfo>> mReceivers;
    113 
    114     // locks for data receiver and StatsCompanionService changes
    115     Mutex mLock;
    116 
    117     void updateAlarmLocked();
    118 
    119     int64_t mNextPullTimeNs;
    120 
    121     FRIEND_TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvents);
    122     FRIEND_TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvent_LateAlarm);
    123     FRIEND_TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsWithActivation);
    124     FRIEND_TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsNoCondition);
    125     FRIEND_TEST(ValueMetricE2eTest, TestPulledEvents);
    126     FRIEND_TEST(ValueMetricE2eTest, TestPulledEvents_LateAlarm);
    127     FRIEND_TEST(ValueMetricE2eTest, TestPulledEvents_WithActivation);
    128 };
    129 
    130 }  // namespace statsd
    131 }  // namespace os
    132 }  // namespace android
    133