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

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

Merge "Log uid info to KeyValuePairAtom"

parents f2e324bc 1a2a3994

cmds/statsd/src/logd/LogEvent.cpp

+11 −3
Original line number Diff line number Diff line
@@ -267,10 +267,12 @@ LogEvent::LogEvent(int64_t wallClockTimestampNs, int64_t elapsedTimestampNs, 
    }

}



LogEvent::LogEvent(int32_t tagId, int64_t timestampNs) {

LogEvent::LogEvent(int32_t tagId, int64_t timestampNs) : LogEvent(tagId, timestampNs, 0) {}



LogEvent::LogEvent(int32_t tagId, int64_t timestampNs, int32_t uid) {

    mLogdTimestampNs = timestampNs;

    mTagId = tagId;

    mLogUid = 0;

    mLogUid = uid;

    mContext = create_android_logger(1937006964); // the event tag shared by all stats logs

    if (mContext) {

        android_log_write_int64(mContext, timestampNs);
@@ -344,7 +346,8 @@ bool LogEvent::write(float value) { 
    return false;

}



bool LogEvent::writeKeyValuePairs(const std::map<int32_t, int32_t>& int_map,

bool LogEvent::writeKeyValuePairs(int32_t uid,

                                  const std::map<int32_t, int32_t>& int_map,

                                  const std::map<int32_t, int64_t>& long_map,

                                  const std::map<int32_t, std::string>& string_map,

                                  const std::map<int32_t, float>& float_map) {
@@ -352,6 +355,7 @@ bool LogEvent::writeKeyValuePairs(const std::map<int32_t, int32_t>& int_map, 
         if (android_log_write_list_begin(mContext) < 0) {

            return false;

         }

         write(uid);

         for (const auto& itr : int_map) {

             if (android_log_write_list_begin(mContext) < 0) {

                return false;
@@ -561,6 +565,10 @@ void LogEvent::init(android_log_context context) { 
        }

        i++;

    } while ((elem.type != EVENT_TYPE_UNKNOWN) && !elem.complete);

    if (isKeyValuePairAtom && mValues.size() > 0) {

        mValues[0] = FieldValue(Field(android::util::KEY_VALUE_PAIRS_ATOM, getSimpleField(1)),

                                Value((int32_t)mLogUid));

    }

}



int64_t LogEvent::GetLong(size_t key, status_t* err) const {

cmds/statsd/src/logd/LogEvent.h

+5 −1
Original line number Diff line number Diff line
@@ -75,6 +75,9 @@ public: 
    // For testing. The timestamp is used as both elapsed real time and logd timestamp.

    explicit LogEvent(int32_t tagId, int64_t timestampNs);



    // For testing. The timestamp is used as both elapsed real time and logd timestamp.

    explicit LogEvent(int32_t tagId, int64_t timestampNs, int32_t uid);



    /**

     * Constructs a KeyValuePairsAtom LogEvent from value maps.

     */
@@ -147,7 +150,8 @@ public: 
    bool write(float value);

    bool write(const std::vector<AttributionNodeInternal>& nodes);

    bool write(const AttributionNodeInternal& node);

    bool writeKeyValuePairs(const std::map<int32_t, int32_t>& int_map,

    bool writeKeyValuePairs(int32_t uid,

                            const std::map<int32_t, int32_t>& int_map,

                            const std::map<int32_t, int64_t>& long_map,

                            const std::map<int32_t, std::string>& string_map,

                            const std::map<int32_t, float>& float_map);

cmds/statsd/tests/LogEvent_test.cpp

+53 −46
Original line number Diff line number Diff line
@@ -90,7 +90,7 @@ TEST(LogEventTest, TestLogParsing) { 
}



TEST(LogEventTest, TestKeyValuePairsAtomParsing) {

    LogEvent event1(83, 2000);

    LogEvent event1(83, 2000, 1000);

    std::map<int32_t, int32_t> int_map;

    std::map<int32_t, int64_t> long_map;

    std::map<int32_t, std::string> string_map;
@@ -108,7 +108,8 @@ TEST(LogEventTest, TestKeyValuePairsAtomParsing) { 
    float_map[111] = 2.2f;

    float_map[222] = 1.1f;



    EXPECT_TRUE(event1.writeKeyValuePairs(int_map,

    EXPECT_TRUE(event1.writeKeyValuePairs(0, // Logging side logs 0 uid.

                                          int_map,

                                          long_map,

                                          string_map,

                                          float_map));
@@ -116,87 +117,92 @@ TEST(LogEventTest, TestKeyValuePairsAtomParsing) { 


    EXPECT_EQ(83, event1.GetTagId());

    const auto& items = event1.getValues();

    EXPECT_EQ((size_t)16, items.size());

    EXPECT_EQ((size_t)17, items.size());



    const FieldValue& item0 = event1.getValues()[0];

    EXPECT_EQ(0x2010101, item0.mField.getField());

    EXPECT_EQ(0x10000, item0.mField.getField());

    EXPECT_EQ(Type::INT, item0.mValue.getType());

    EXPECT_EQ(11, item0.mValue.int_value);

    EXPECT_EQ(1000, item0.mValue.int_value);



    const FieldValue& item1 = event1.getValues()[1];

    EXPECT_EQ(0x2010182, item1.mField.getField());

    EXPECT_EQ(0x2010201, item1.mField.getField());

    EXPECT_EQ(Type::INT, item1.mValue.getType());

    EXPECT_EQ(123, item1.mValue.int_value);

    EXPECT_EQ(11, item1.mValue.int_value);



    const FieldValue& item2 = event1.getValues()[2];

    EXPECT_EQ(0x2010201, item2.mField.getField());

    EXPECT_EQ(0x2010282, item2.mField.getField());

    EXPECT_EQ(Type::INT, item2.mValue.getType());

    EXPECT_EQ(22, item2.mValue.int_value);

    EXPECT_EQ(123, item2.mValue.int_value);



    const FieldValue& item3 = event1.getValues()[3];

    EXPECT_EQ(0x2010282, item3.mField.getField());

    EXPECT_EQ(0x2010301, item3.mField.getField());

    EXPECT_EQ(Type::INT, item3.mValue.getType());

    EXPECT_EQ(345, item3.mValue.int_value);

    EXPECT_EQ(22, item3.mValue.int_value);



    const FieldValue& item4 = event1.getValues()[4];

    EXPECT_EQ(0x2010301, item4.mField.getField());

    EXPECT_EQ(0x2010382, item4.mField.getField());

    EXPECT_EQ(Type::INT, item4.mValue.getType());

    EXPECT_EQ(33, item4.mValue.int_value);

    EXPECT_EQ(345, item4.mValue.int_value);



    const FieldValue& item5 = event1.getValues()[5];

    EXPECT_EQ(0x2010382, item5.mField.getField());

    EXPECT_EQ(Type::LONG, item5.mValue.getType());

    EXPECT_EQ(678L, item5.mValue.int_value);

    EXPECT_EQ(0x2010401, item5.mField.getField());

    EXPECT_EQ(Type::INT, item5.mValue.getType());

    EXPECT_EQ(33, item5.mValue.int_value);



    const FieldValue& item6 = event1.getValues()[6];

    EXPECT_EQ(0x2010401, item6.mField.getField());

    EXPECT_EQ(Type::INT, item6.mValue.getType());

    EXPECT_EQ(44, item6.mValue.int_value);

    EXPECT_EQ(0x2010482, item6.mField.getField());

    EXPECT_EQ(Type::LONG, item6.mValue.getType());

    EXPECT_EQ(678L, item6.mValue.int_value);



    const FieldValue& item7 = event1.getValues()[7];

    EXPECT_EQ(0x2010482, item7.mField.getField());

    EXPECT_EQ(Type::LONG, item7.mValue.getType());

    EXPECT_EQ(890L, item7.mValue.int_value);

    EXPECT_EQ(0x2010501, item7.mField.getField());

    EXPECT_EQ(Type::INT, item7.mValue.getType());

    EXPECT_EQ(44, item7.mValue.int_value);



    const FieldValue& item8 = event1.getValues()[8];

    EXPECT_EQ(0x2010501, item8.mField.getField());

    EXPECT_EQ(Type::INT, item8.mValue.getType());

    EXPECT_EQ(1, item8.mValue.int_value);

    EXPECT_EQ(0x2010582, item8.mField.getField());

    EXPECT_EQ(Type::LONG, item8.mValue.getType());

    EXPECT_EQ(890L, item8.mValue.int_value);



    const FieldValue& item9 = event1.getValues()[9];

    EXPECT_EQ(0x2010583, item9.mField.getField());

    EXPECT_EQ(Type::STRING, item9.mValue.getType());

    EXPECT_EQ("test2", item9.mValue.str_value);

    EXPECT_EQ(0x2010601, item9.mField.getField());

    EXPECT_EQ(Type::INT, item9.mValue.getType());

    EXPECT_EQ(1, item9.mValue.int_value);



    const FieldValue& item10 = event1.getValues()[10];

    EXPECT_EQ(0x2010601, item10.mField.getField());

    EXPECT_EQ(Type::INT, item10.mValue.getType());

    EXPECT_EQ(2, item10.mValue.int_value);

    EXPECT_EQ(0x2010683, item10.mField.getField());

    EXPECT_EQ(Type::STRING, item10.mValue.getType());

    EXPECT_EQ("test2", item10.mValue.str_value);



    const FieldValue& item11 = event1.getValues()[11];

    EXPECT_EQ(0x2010683, item11.mField.getField());

    EXPECT_EQ(Type::STRING, item11.mValue.getType());

    EXPECT_EQ("test1", item11.mValue.str_value);

    EXPECT_EQ(0x2010701, item11.mField.getField());

    EXPECT_EQ(Type::INT, item11.mValue.getType());

    EXPECT_EQ(2, item11.mValue.int_value);



    const FieldValue& item12 = event1.getValues()[12];

    EXPECT_EQ(0x2010701, item12.mField.getField());

    EXPECT_EQ(Type::INT, item12.mValue.getType());

    EXPECT_EQ(111, item12.mValue.int_value);

    EXPECT_EQ(0x2010783, item12.mField.getField());

    EXPECT_EQ(Type::STRING, item12.mValue.getType());

    EXPECT_EQ("test1", item12.mValue.str_value);



    const FieldValue& item13 = event1.getValues()[13];

    EXPECT_EQ(0x2010784, item13.mField.getField());

    EXPECT_EQ(Type::FLOAT, item13.mValue.getType());

    EXPECT_EQ(2.2f, item13.mValue.float_value);

    EXPECT_EQ(0x2010801, item13.mField.getField());

    EXPECT_EQ(Type::INT, item13.mValue.getType());

    EXPECT_EQ(111, item13.mValue.int_value);



    const FieldValue& item14 = event1.getValues()[14];

    EXPECT_EQ(0x2018801, item14.mField.getField());

    EXPECT_EQ(Type::INT, item14.mValue.getType());

    EXPECT_EQ(222, item14.mValue.int_value);

    EXPECT_EQ(0x2010884, item14.mField.getField());

    EXPECT_EQ(Type::FLOAT, item14.mValue.getType());

    EXPECT_EQ(2.2f, item14.mValue.float_value);



    const FieldValue& item15 = event1.getValues()[15];

    EXPECT_EQ(0x2018884, item15.mField.getField());

    EXPECT_EQ(Type::FLOAT, item15.mValue.getType());

    EXPECT_EQ(1.1f, item15.mValue.float_value);

    EXPECT_EQ(0x2018901, item15.mField.getField());

    EXPECT_EQ(Type::INT, item15.mValue.getType());

    EXPECT_EQ(222, item15.mValue.int_value);



    const FieldValue& item16 = event1.getValues()[16];

    EXPECT_EQ(0x2018984, item16.mField.getField());

    EXPECT_EQ(Type::FLOAT, item16.mValue.getType());

    EXPECT_EQ(1.1f, item16.mValue.float_value);

}



TEST(LogEventTest, TestLogParsing2) {
@@ -292,6 +298,7 @@ TEST(LogEventTest, TestKeyValuePairsEvent) { 
    EXPECT_EQ(83, event1.GetTagId());

    EXPECT_EQ((int64_t)2000, event1.GetLogdTimestampNs());

    EXPECT_EQ((int64_t)2001, event1.GetElapsedTimestampNs());

    EXPECT_EQ((int64_t)10001, event1.GetUid());



    const auto& items = event1.getValues();

    EXPECT_EQ((size_t)17, items.size());