Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 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 | |
Yao Chen | 8a8d16c | 2018-02-08 14:50:40 -0800 | [diff] [blame] | 19 | #include "FieldValue.h" |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 20 | |
Howard Ro | a46b658 | 2018-09-18 16:45:02 -0700 | [diff] [blame] | 21 | #include <android/frameworks/stats/1.0/types.h> |
Yao Chen | 5110bed | 2017-10-23 12:50:02 -0700 | [diff] [blame] | 22 | #include <android/util/ProtoOutputStream.h> |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 23 | #include <log/log_read.h> |
Yao Chen | 8023540 | 2017-11-13 20:42:25 -0800 | [diff] [blame] | 24 | #include <private/android_logger.h> |
Tej Singh | a02bfab | 2019-10-01 19:03:24 -0700 | [diff] [blame] | 25 | #include <stats_event_list.h> |
Ruchir Rastogi | 1fb525e | 2019-11-07 14:08:24 -0800 | [diff] [blame] | 26 | #include <stats_event.h> |
Yao Chen | 5110bed | 2017-10-23 12:50:02 -0700 | [diff] [blame] | 27 | #include <utils/Errors.h> |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 28 | |
| 29 | #include <string> |
| 30 | #include <vector> |
| 31 | |
Howard Ro | a46b658 | 2018-09-18 16:45:02 -0700 | [diff] [blame] | 32 | using namespace android::frameworks::stats::V1_0; |
| 33 | |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 34 | namespace android { |
| 35 | namespace os { |
| 36 | namespace statsd { |
| 37 | |
Yao Chen | 9c1debe | 2018-02-19 14:39:19 -0800 | [diff] [blame] | 38 | struct AttributionNodeInternal { |
| 39 | void set_uid(int32_t id) { |
| 40 | mUid = id; |
| 41 | } |
| 42 | |
| 43 | void set_tag(const std::string& value) { |
| 44 | mTag = value; |
| 45 | } |
| 46 | |
| 47 | int32_t uid() const { |
| 48 | return mUid; |
| 49 | } |
| 50 | |
| 51 | const std::string& tag() const { |
| 52 | return mTag; |
| 53 | } |
| 54 | |
| 55 | int32_t mUid; |
| 56 | std::string mTag; |
| 57 | }; |
Chenjie Yu | 97dbb20 | 2019-02-13 16:42:04 -0800 | [diff] [blame] | 58 | |
| 59 | struct InstallTrainInfo { |
| 60 | int64_t trainVersionCode; |
Muhammad Qureshi | f4ca824 | 2019-03-01 09:20:15 -0800 | [diff] [blame] | 61 | std::string trainName; |
| 62 | int32_t status; |
Jeff Hamilton | fa2f91c | 2019-03-22 00:25:02 -0400 | [diff] [blame] | 63 | std::vector<int64_t> experimentIds; |
Chenjie Yu | 97dbb20 | 2019-02-13 16:42:04 -0800 | [diff] [blame] | 64 | }; |
Jeff Hamilton | fa2f91c | 2019-03-22 00:25:02 -0400 | [diff] [blame] | 65 | |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 66 | /** |
| 67 | * Wrapper for the log_msg structure. |
| 68 | */ |
| 69 | class LogEvent { |
| 70 | public: |
| 71 | /** |
Ruchir Rastogi | 1736ba4 | 2019-11-04 14:37:13 -0800 | [diff] [blame] | 72 | * Read a LogEvent from the socket |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 73 | */ |
Ruchir Rastogi | 1736ba4 | 2019-11-04 14:37:13 -0800 | [diff] [blame] | 74 | explicit LogEvent(uint8_t* msg, uint32_t len, uint32_t uid); |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 75 | |
Chenjie Yu | d7e3a22 | 2018-11-28 21:29:44 +0000 | [diff] [blame] | 76 | /** |
Tej Singh | 8981763 | 2019-12-09 16:58:08 -0800 | [diff] [blame] | 77 | * Temp constructor to use for pulled atoms until we flip the socket schema. |
| 78 | */ |
| 79 | explicit LogEvent(uint8_t* msg, uint32_t len, uint32_t uid, bool useNewSchema); |
| 80 | |
| 81 | /** |
Yao Chen | 8023540 | 2017-11-13 20:42:25 -0800 | [diff] [blame] | 82 | * Constructs a LogEvent with synthetic data for testing. Must call init() before reading. |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 83 | */ |
Yangster-mac | 330af58 | 2018-02-08 15:24:38 -0800 | [diff] [blame] | 84 | explicit LogEvent(int32_t tagId, int64_t wallClockTimestampNs, int64_t elapsedTimestampNs); |
| 85 | |
| 86 | // For testing. The timestamp is used as both elapsed real time and logd timestamp. |
| 87 | explicit LogEvent(int32_t tagId, int64_t timestampNs); |
David Chen | 1481fe1 | 2017-10-16 13:16:34 -0700 | [diff] [blame] | 88 | |
Howard Ro | 1a2a399 | 2018-10-22 22:51:57 -0700 | [diff] [blame] | 89 | // For testing. The timestamp is used as both elapsed real time and logd timestamp. |
| 90 | explicit LogEvent(int32_t tagId, int64_t timestampNs, int32_t uid); |
| 91 | |
Yangster-mac | 48b3d62 | 2018-08-18 12:38:11 -0700 | [diff] [blame] | 92 | /** |
| 93 | * Constructs a KeyValuePairsAtom LogEvent from value maps. |
| 94 | */ |
| 95 | explicit LogEvent(int32_t tagId, int64_t wallClockTimestampNs, int64_t elapsedTimestampNs, |
| 96 | int32_t uid, |
Howard Ro | 4078dd4 | 2018-09-27 17:41:08 -0700 | [diff] [blame] | 97 | const std::map<int32_t, int32_t>& int_map, |
| 98 | const std::map<int32_t, int64_t>& long_map, |
Yangster-mac | 48b3d62 | 2018-08-18 12:38:11 -0700 | [diff] [blame] | 99 | const std::map<int32_t, std::string>& string_map, |
| 100 | const std::map<int32_t, float>& float_map); |
| 101 | |
Chenjie Yu | 6b1667c | 2019-01-18 10:09:33 -0800 | [diff] [blame] | 102 | // Constructs a BinaryPushStateChanged LogEvent from API call. |
| 103 | explicit LogEvent(const std::string& trainName, int64_t trainVersionCode, bool requiresStaging, |
| 104 | bool rollbackEnabled, bool requiresLowLatencyMonitor, int32_t state, |
| 105 | const std::vector<uint8_t>& experimentIds, int32_t userId); |
| 106 | |
Howard Ro | a46b658 | 2018-09-18 16:45:02 -0700 | [diff] [blame] | 107 | explicit LogEvent(int64_t wallClockTimestampNs, int64_t elapsedTimestampNs, |
Maggie White | 58174da | 2019-01-18 15:23:35 -0800 | [diff] [blame] | 108 | const VendorAtom& vendorAtom); |
| 109 | |
Chenjie Yu | 97dbb20 | 2019-02-13 16:42:04 -0800 | [diff] [blame] | 110 | explicit LogEvent(int64_t wallClockTimestampNs, int64_t elapsedTimestampNs, |
| 111 | const InstallTrainInfo& installTrainInfo); |
| 112 | |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 113 | ~LogEvent(); |
| 114 | |
| 115 | /** |
| 116 | * Get the timestamp associated with this event. |
| 117 | */ |
Yangster-mac | 330af58 | 2018-02-08 15:24:38 -0800 | [diff] [blame] | 118 | inline int64_t GetLogdTimestampNs() const { return mLogdTimestampNs; } |
| 119 | inline int64_t GetElapsedTimestampNs() const { return mElapsedTimestampNs; } |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 120 | |
| 121 | /** |
| 122 | * Get the tag for this event. |
| 123 | */ |
Yangster-mac | 6898580 | 2018-01-21 10:05:09 -0800 | [diff] [blame] | 124 | inline int GetTagId() const { return mTagId; } |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 125 | |
Yangster-mac | 6898580 | 2018-01-21 10:05:09 -0800 | [diff] [blame] | 126 | inline uint32_t GetUid() const { |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 127 | return mLogUid; |
| 128 | } |
| 129 | |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 130 | /** |
| 131 | * Get the nth value, starting at 1. |
| 132 | * |
| 133 | * Returns BAD_INDEX if the index is larger than the number of elements. |
| 134 | * Returns BAD_TYPE if the index is available but the data is the wrong type. |
| 135 | */ |
| 136 | int64_t GetLong(size_t key, status_t* err) const; |
Chenjie Yu | 80f9112 | 2018-01-31 20:24:50 -0800 | [diff] [blame] | 137 | int GetInt(size_t key, status_t* err) const; |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 138 | const char* GetString(size_t key, status_t* err) const; |
| 139 | bool GetBool(size_t key, status_t* err) const; |
| 140 | float GetFloat(size_t key, status_t* err) const; |
| 141 | |
| 142 | /** |
Yao Chen | 8023540 | 2017-11-13 20:42:25 -0800 | [diff] [blame] | 143 | * Write test data to the LogEvent. This can only be used when the LogEvent is constructed |
| 144 | * using LogEvent(tagId, timestampNs). You need to call init() before you can read from it. |
| 145 | */ |
| 146 | bool write(uint32_t value); |
| 147 | bool write(int32_t value); |
| 148 | bool write(uint64_t value); |
| 149 | bool write(int64_t value); |
Yao Chen | 9c1debe | 2018-02-19 14:39:19 -0800 | [diff] [blame] | 150 | bool write(const std::string& value); |
Yao Chen | 8023540 | 2017-11-13 20:42:25 -0800 | [diff] [blame] | 151 | bool write(float value); |
Yao Chen | 9c1debe | 2018-02-19 14:39:19 -0800 | [diff] [blame] | 152 | bool write(const std::vector<AttributionNodeInternal>& nodes); |
| 153 | bool write(const AttributionNodeInternal& node); |
Tej Singh | a02bfab | 2019-10-01 19:03:24 -0700 | [diff] [blame] | 154 | bool writeBytes(const std::string& value); |
Howard Ro | 1a2a399 | 2018-10-22 22:51:57 -0700 | [diff] [blame] | 155 | bool writeKeyValuePairs(int32_t uid, |
| 156 | const std::map<int32_t, int32_t>& int_map, |
Howard Ro | 4078dd4 | 2018-09-27 17:41:08 -0700 | [diff] [blame] | 157 | const std::map<int32_t, int64_t>& long_map, |
Yangster-mac | e124e42 | 2018-08-16 10:30:28 -0700 | [diff] [blame] | 158 | const std::map<int32_t, std::string>& string_map, |
| 159 | const std::map<int32_t, float>& float_map); |
Yao Chen | 8023540 | 2017-11-13 20:42:25 -0800 | [diff] [blame] | 160 | |
| 161 | /** |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 162 | * Return a string representation of this event. |
| 163 | */ |
Yao Chen | 9c1debe | 2018-02-19 14:39:19 -0800 | [diff] [blame] | 164 | std::string ToString() const; |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 165 | |
| 166 | /** |
Yao Chen | 5110bed | 2017-10-23 12:50:02 -0700 | [diff] [blame] | 167 | * Write this object to a ProtoOutputStream. |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 168 | */ |
Yao Chen | 5110bed | 2017-10-23 12:50:02 -0700 | [diff] [blame] | 169 | void ToProto(android::util::ProtoOutputStream& out) const; |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 170 | |
David Chen | 1481fe1 | 2017-10-16 13:16:34 -0700 | [diff] [blame] | 171 | /** |
David Chen | 1481fe1 | 2017-10-16 13:16:34 -0700 | [diff] [blame] | 172 | * Used with the constructor where tag is passed in. Converts the log_event_list to read mode |
| 173 | * and prepares the list for reading. |
| 174 | */ |
| 175 | void init(); |
| 176 | |
Chenjie Yu | a7259ab | 2017-12-10 08:31:05 -0800 | [diff] [blame] | 177 | /** |
Yangster-mac | 330af58 | 2018-02-08 15:24:38 -0800 | [diff] [blame] | 178 | * Set elapsed timestamp if the original timestamp is missing. |
Chenjie Yu | a7259ab | 2017-12-10 08:31:05 -0800 | [diff] [blame] | 179 | */ |
Yangster-mac | 330af58 | 2018-02-08 15:24:38 -0800 | [diff] [blame] | 180 | void setElapsedTimestampNs(int64_t timestampNs) { |
| 181 | mElapsedTimestampNs = timestampNs; |
| 182 | } |
| 183 | |
| 184 | /** |
| 185 | * Set the timestamp if the original logd timestamp is missing. |
| 186 | */ |
| 187 | void setLogdWallClockTimestampNs(int64_t timestampNs) { |
| 188 | mLogdTimestampNs = timestampNs; |
| 189 | } |
Chenjie Yu | a7259ab | 2017-12-10 08:31:05 -0800 | [diff] [blame] | 190 | |
Yangster-mac | 2087716 | 2017-12-22 17:19:39 -0800 | [diff] [blame] | 191 | inline int size() const { |
Yao Chen | 8a8d16c | 2018-02-08 14:50:40 -0800 | [diff] [blame] | 192 | return mValues.size(); |
Chenjie Yu | d9dfda7 | 2017-12-11 17:41:20 -0800 | [diff] [blame] | 193 | } |
| 194 | |
Yao Chen | 8a8d16c | 2018-02-08 14:50:40 -0800 | [diff] [blame] | 195 | const std::vector<FieldValue>& getValues() const { |
| 196 | return mValues; |
| 197 | } |
Yangster-mac | d40053e | 2018-01-09 16:29:22 -0800 | [diff] [blame] | 198 | |
Yao Chen | 8a8d16c | 2018-02-08 14:50:40 -0800 | [diff] [blame] | 199 | std::vector<FieldValue>* getMutableValues() { |
| 200 | return &mValues; |
| 201 | } |
Yangster-mac | 2087716 | 2017-12-22 17:19:39 -0800 | [diff] [blame] | 202 | |
Ruchir Rastogi | 1736ba4 | 2019-11-04 14:37:13 -0800 | [diff] [blame] | 203 | bool isValid() { |
| 204 | return mValid; |
| 205 | } |
| 206 | |
Chenjie Yu | 0bd73db | 2018-12-16 07:37:04 -0800 | [diff] [blame] | 207 | inline LogEvent makeCopy() { |
| 208 | return LogEvent(*this); |
| 209 | } |
| 210 | |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 211 | private: |
| 212 | /** |
Chenjie Yu | 0bd73db | 2018-12-16 07:37:04 -0800 | [diff] [blame] | 213 | * Only use this if copy is absolutely needed. |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 214 | */ |
Chih-Hung Hsieh | 3227aab | 2018-12-20 13:42:28 -0800 | [diff] [blame] | 215 | LogEvent(const LogEvent&); |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 216 | |
Ruchir Rastogi | 1736ba4 | 2019-11-04 14:37:13 -0800 | [diff] [blame] | 217 | |
| 218 | /** |
| 219 | * Parsing function for new encoding scheme. |
| 220 | */ |
| 221 | void initNew(); |
| 222 | |
| 223 | void parseInt32(int32_t* pos, int32_t depth, bool* last); |
| 224 | void parseInt64(int32_t* pos, int32_t depth, bool* last); |
| 225 | void parseString(int32_t* pos, int32_t depth, bool* last); |
| 226 | void parseFloat(int32_t* pos, int32_t depth, bool* last); |
| 227 | void parseBool(int32_t* pos, int32_t depth, bool* last); |
| 228 | void parseByteArray(int32_t* pos, int32_t depth, bool* last); |
| 229 | void parseKeyValuePairs(int32_t* pos, int32_t depth, bool* last); |
| 230 | void parseAttributionChain(int32_t* pos, int32_t depth, bool* last); |
| 231 | |
| 232 | /** |
| 233 | * mBuf is a pointer to the current location in the buffer being parsed. |
| 234 | * Because the buffer lives on the StatsSocketListener stack, this pointer |
| 235 | * is only valid during the LogEvent constructor. It will be set to null at |
| 236 | * the end of initNew. |
| 237 | */ |
| 238 | uint8_t* mBuf; |
| 239 | |
| 240 | uint32_t mRemainingLen; // number of valid bytes left in the buffer being parsed |
| 241 | bool mValid = true; // stores whether the event we received from the socket is valid |
| 242 | |
| 243 | /** |
| 244 | * Side-effects: |
| 245 | * If there is enough space in buffer to read value of type T |
| 246 | * - move mBuf past the value that was just read |
| 247 | * - decrement mRemainingLen by size of T |
| 248 | * Else |
| 249 | * - set mValid to false |
| 250 | */ |
| 251 | template <class T> |
| 252 | T readNextValue() { |
| 253 | T value; |
| 254 | if (mRemainingLen < sizeof(T)) { |
| 255 | mValid = false; |
| 256 | value = 0; // all primitive types can successfully cast 0 |
| 257 | } else { |
| 258 | value = *((T*)mBuf); |
| 259 | mBuf += sizeof(T); |
| 260 | mRemainingLen -= sizeof(T); |
| 261 | } |
| 262 | return value; |
| 263 | } |
| 264 | |
| 265 | template <class T> |
| 266 | void addToValues(int32_t* pos, int32_t depth, T& value, bool* last) { |
| 267 | Field f = Field(mTagId, pos, depth); |
| 268 | // do not decorate last position at depth 0 |
| 269 | for (int i = 1; i < depth; i++) { |
| 270 | if (last[i]) f.decorateLastPos(i); |
| 271 | } |
| 272 | |
| 273 | Value v = Value(value); |
| 274 | mValues.push_back(FieldValue(f, v)); |
| 275 | } |
| 276 | |
| 277 | uint8_t getTypeId(uint8_t typeInfo); |
| 278 | uint8_t getNumAnnotations(uint8_t typeInfo); |
| 279 | |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 280 | /** |
| 281 | * Parses a log_msg into a LogEvent object. |
| 282 | */ |
Yao Chen | 8023540 | 2017-11-13 20:42:25 -0800 | [diff] [blame] | 283 | void init(android_log_context context); |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 284 | |
Yao Chen | 8a8d16c | 2018-02-08 14:50:40 -0800 | [diff] [blame] | 285 | // The items are naturally sorted in DFS order as we read them. this allows us to do fast |
| 286 | // matching. |
| 287 | std::vector<FieldValue> mValues; |
Yao Chen | 8023540 | 2017-11-13 20:42:25 -0800 | [diff] [blame] | 288 | |
Yangster-mac | 2087716 | 2017-12-22 17:19:39 -0800 | [diff] [blame] | 289 | // This field is used when statsD wants to create log event object and write fields to it. After |
| 290 | // calling init() function, this object would be destroyed to save memory usage. |
| 291 | // When the log event is created from log msg, this field is never initiated. |
Yao Chen | 48d7518 | 2018-01-23 09:40:48 -0800 | [diff] [blame] | 292 | android_log_context mContext = NULL; |
Yao Chen | 93fe3a3 | 2017-11-02 13:52:59 -0700 | [diff] [blame] | 293 | |
Yangster-mac | 330af58 | 2018-02-08 15:24:38 -0800 | [diff] [blame] | 294 | // The timestamp set by the logd. |
| 295 | int64_t mLogdTimestampNs; |
| 296 | |
| 297 | // The elapsed timestamp set by statsd log writer. |
| 298 | int64_t mElapsedTimestampNs; |
Yao Chen | 93fe3a3 | 2017-11-02 13:52:59 -0700 | [diff] [blame] | 299 | |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 300 | int mTagId; |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 301 | |
| 302 | uint32_t mLogUid; |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 303 | }; |
| 304 | |
Jeff Hamilton | fa2f91c | 2019-03-22 00:25:02 -0400 | [diff] [blame] | 305 | void writeExperimentIdsToProto(const std::vector<int64_t>& experimentIds, std::vector<uint8_t>* protoOut); |
| 306 | |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 307 | } // namespace statsd |
| 308 | } // namespace os |
| 309 | } // namespace android |
| 310 | |