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

Commit c7911dd0 authored by tsaichristine's avatar tsaichristine
Browse files

Clean up unused LogEvent constructors 

After switching to the new socket schema, we can remove certain LogEvent
constructors. AttributionNodeInternal was only used in tests and can be
removed as well.

Bug: 14959031
Test: bit statsd_test:*
Change-Id: Ib5cb6acc50cc4d37a46a076d41face452a0a87d8
parent 2328849c

cmds/statsd/benchmark/metric_util.cpp

+0 −7
Original line number Diff line number Diff line
@@ -370,13 +370,6 @@ sp<StatsLogProcessor> CreateStatsLogProcessor(const long timeBaseSec, const Stat 
    return processor;

}



AttributionNodeInternal CreateAttribution(const int& uid, const string& tag) {

    AttributionNodeInternal attribution;

    attribution.set_uid(uid);

    attribution.set_tag(tag);

    return attribution;

}



void sortLogEventsByTimestamp(std::vector<std::unique_ptr<LogEvent>> *events) {

  std::sort(events->begin(), events->end(),

            [](const std::unique_ptr<LogEvent>& a, const std::unique_ptr<LogEvent>& b) {

cmds/statsd/benchmark/metric_util.h

+0 −3
Original line number Diff line number Diff line
@@ -120,9 +120,6 @@ std::unique_ptr<LogEvent> CreateSyncEndEvent(uint64_t timestampNs, 
                                             const vector<string>& attributionTags,

                                             const string& name);



// Helper function to create an AttributionNodeInternal proto.

AttributionNodeInternal CreateAttribution(const int& uid, const string& tag);



// Create a statsd log event processor upon the start time in seconds, config and key.

sp<StatsLogProcessor> CreateStatsLogProcessor(const long timeBaseSec, const StatsdConfig& config,

                                              const ConfigKey& key);

cmds/statsd/src/logd/LogEvent.cpp

+0 −227
Original line number Diff line number Diff line
@@ -81,74 +81,6 @@ LogEvent::LogEvent(int32_t uid, int32_t pid) 
      mLogPid(pid) {

}



LogEvent::LogEvent(int32_t tagId, int64_t wallClockTimestampNs, int64_t elapsedTimestampNs) {

    mLogdTimestampNs = wallClockTimestampNs;

    mElapsedTimestampNs = elapsedTimestampNs;

    mTagId = tagId;

    mLogUid = 0;

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

    if (mContext) {

        android_log_write_int64(mContext, elapsedTimestampNs);

        android_log_write_int32(mContext, tagId);

    }

}



LogEvent::LogEvent(int32_t tagId, int64_t wallClockTimestampNs, int64_t elapsedTimestampNs,

                   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) {

    mLogdTimestampNs = wallClockTimestampNs;

    mElapsedTimestampNs = elapsedTimestampNs;

    mTagId = util::KEY_VALUE_PAIRS_ATOM;

    mLogUid = uid;



    int pos[] = {1, 1, 1};



    mValues.push_back(FieldValue(Field(mTagId, pos, 0 /* depth */), Value(uid)));

    pos[0]++;

    for (const auto&itr : int_map) {

        pos[2] = 1;

        mValues.push_back(FieldValue(Field(mTagId, pos, 2 /* depth */), Value(itr.first)));

        pos[2] = 2;

        mValues.push_back(FieldValue(Field(mTagId, pos, 2 /* depth */), Value(itr.second)));

        mValues.back().mField.decorateLastPos(2);

        pos[1]++;

    }



    for (const auto&itr : long_map) {

        pos[2] = 1;

        mValues.push_back(FieldValue(Field(mTagId, pos, 2 /* depth */), Value(itr.first)));

        pos[2] = 3;

        mValues.push_back(FieldValue(Field(mTagId, pos, 2 /* depth */), Value(itr.second)));

        mValues.back().mField.decorateLastPos(2);

        pos[1]++;

    }



    for (const auto&itr : string_map) {

        pos[2] = 1;

        mValues.push_back(FieldValue(Field(mTagId, pos, 2 /* depth */), Value(itr.first)));

        pos[2] = 4;

        mValues.push_back(FieldValue(Field(mTagId, pos, 2 /* depth */), Value(itr.second)));

        mValues.back().mField.decorateLastPos(2);

        pos[1]++;

    }



    for (const auto&itr : float_map) {

        pos[2] = 1;

        mValues.push_back(FieldValue(Field(mTagId, pos, 2 /* depth */), Value(itr.first)));

        pos[2] = 5;

        mValues.push_back(FieldValue(Field(mTagId, pos, 2 /* depth */), Value(itr.second)));

        mValues.back().mField.decorateLastPos(2);

        pos[1]++;

    }

    if (!mValues.empty()) {

        mValues.back().mField.decorateLastPos(1);

        mValues.at(mValues.size() - 2).mField.decorateLastPos(1);

    }

}



LogEvent::LogEvent(const string& trainName, int64_t trainVersionCode, bool requiresStaging,

                   bool rollbackEnabled, bool requiresLowLatencyMonitor, int32_t state,

                   const std::vector<uint8_t>& experimentIds, int32_t userId) {
@@ -184,17 +116,6 @@ LogEvent::LogEvent(int64_t wallClockTimestampNs, int64_t elapsedTimestampNs, 
    mValues.push_back(FieldValue(Field(mTagId, getSimpleField(4)), Value(trainInfo.status)));

}



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

    mLogdTimestampNs = timestampNs;

    mTagId = tagId;

    mLogUid = uid;

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

    if (mContext) {

        android_log_write_int64(mContext, timestampNs);

        android_log_write_int32(mContext, tagId);

    }

}



LogEvent::~LogEvent() {

    if (mContext) {

        // This is for the case when LogEvent is created using the test interface
@@ -203,154 +124,6 @@ LogEvent::~LogEvent() { 
    }

}



bool LogEvent::write(int32_t value) {

    if (mContext) {

        return android_log_write_int32(mContext, value) >= 0;

    }

    return false;

}



bool LogEvent::write(uint32_t value) {

    if (mContext) {

        return android_log_write_int32(mContext, value) >= 0;

    }

    return false;

}



bool LogEvent::write(int64_t value) {

    if (mContext) {

        return android_log_write_int64(mContext, value) >= 0;

    }

    return false;

}



bool LogEvent::write(uint64_t value) {

    if (mContext) {

        return android_log_write_int64(mContext, value) >= 0;

    }

    return false;

}



bool LogEvent::write(const string& value) {

    if (mContext) {

        return android_log_write_string8_len(mContext, value.c_str(), value.length()) >= 0;

    }

    return false;

}



bool LogEvent::write(float value) {

    if (mContext) {

        return android_log_write_float32(mContext, value) >= 0;

    }

    return false;

}



bool LogEvent::writeBytes(const string& value) {

    /* if (mContext) {

        return android_log_write_char_array(mContext, value.c_str(), value.length()) >= 0;

    }*/

    return false;

}



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) {

    if (mContext) {

         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;

             }

             write(itr.first);

             write(itr.second);

             if (android_log_write_list_end(mContext) < 0) {

                return false;

             }

         }



         for (const auto& itr : long_map) {

             if (android_log_write_list_begin(mContext) < 0) {

                return false;

             }

             write(itr.first);

             write(itr.second);

             if (android_log_write_list_end(mContext) < 0) {

                return false;

             }

         }



         for (const auto& itr : string_map) {

             if (android_log_write_list_begin(mContext) < 0) {

                return false;

             }

             write(itr.first);

             write(itr.second.c_str());

             if (android_log_write_list_end(mContext) < 0) {

                return false;

             }

         }



         for (const auto& itr : float_map) {

             if (android_log_write_list_begin(mContext) < 0) {

                return false;

             }

             write(itr.first);

             write(itr.second);

             if (android_log_write_list_end(mContext) < 0) {

                return false;

             }

         }



         if (android_log_write_list_end(mContext) < 0) {

            return false;

         }

         return true;

    }

    return false;

}



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

    if (mContext) {

         if (android_log_write_list_begin(mContext) < 0) {

            return false;

         }

         for (size_t i = 0; i < nodes.size(); ++i) {

             if (!write(nodes[i])) {

                return false;

             }

         }

         if (android_log_write_list_end(mContext) < 0) {

            return false;

         }

         return true;

    }

    return false;

}



bool LogEvent::write(const AttributionNodeInternal& node) {

    if (mContext) {

         if (android_log_write_list_begin(mContext) < 0) {

            return false;

         }

         if (android_log_write_int32(mContext, node.uid()) < 0) {

            return false;

         }

         if (android_log_write_string8(mContext, node.tag().c_str()) < 0) {

            return false;

         }

         if (android_log_write_list_end(mContext) < 0) {

            return false;

         }

         return true;

    }

    return false;

}



void LogEvent::parseInt32(int32_t* pos, int32_t depth, bool* last, uint8_t numAnnotations) {

    int32_t value = readNextValue<int32_t>();

    addToValues(pos, depth, value, last);

cmds/statsd/src/logd/LogEvent.h

+0 −62
Original line number Diff line number Diff line
@@ -28,27 +28,6 @@ namespace android { 
namespace os {

namespace statsd {



struct AttributionNodeInternal {

    void set_uid(int32_t id) {

        mUid = id;

    }



    void set_tag(const std::string& value) {

        mTag = value;

    }



    int32_t uid() const {

        return mUid;

    }



    const std::string& tag() const {

        return mTag;

    }



    int32_t mUid;

    std::string mTag;

};



struct InstallTrainInfo {

    int64_t trainVersionCode;

    std::string trainName;
@@ -83,28 +62,6 @@ public: 
     */

    bool parseBuffer(uint8_t* buf, size_t len);



    // TODO(b/149590301): delete unused functions below once LogEvent uses the

    // new socket schema within test code. Really we would like the only entry

    // points into LogEvent to be the above constructor and parseBuffer functions.



    /**

     * Constructs a LogEvent with synthetic data for testing. Must call init() before reading.

     */

    explicit LogEvent(int32_t tagId, int64_t wallClockTimestampNs, int64_t elapsedTimestampNs);



    // 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.

     */

    explicit LogEvent(int32_t tagId, int64_t wallClockTimestampNs, int64_t elapsedTimestampNs,

                      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);



    // Constructs a BinaryPushStateChanged LogEvent from API call.

    explicit LogEvent(const std::string& trainName, int64_t trainVersionCode, bool requiresStaging,

                      bool rollbackEnabled, bool requiresLowLatencyMonitor, int32_t state,
@@ -151,25 +108,6 @@ public: 
    float GetFloat(size_t key, status_t* err) const;

    std::vector<uint8_t> GetStorage(size_t key, status_t* err) const;



    /**

     * Write test data to the LogEvent. This can only be used when the LogEvent is constructed

     * using LogEvent(tagId, timestampNs). You need to call init() before you can read from it.

     */

    bool write(uint32_t value);

    bool write(int32_t value);

    bool write(uint64_t value);

    bool write(int64_t value);

    bool write(const std::string& value);

    bool write(float value);

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

    bool write(const AttributionNodeInternal& node);

    bool writeBytes(const std::string& value);

    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);



    /**

     * Return a string representation of this event.

     */

cmds/statsd/tests/statsd_test_util.cpp

+0 −7
Original line number Diff line number Diff line
@@ -946,13 +946,6 @@ sp<StatsLogProcessor> CreateStatsLogProcessor(const int64_t timeBaseNs, const in 
    return processor;

}



AttributionNodeInternal CreateAttribution(const int& uid, const string& tag) {

    AttributionNodeInternal attribution;

    attribution.set_uid(uid);

    attribution.set_tag(tag);

    return attribution;

}



void sortLogEventsByTimestamp(std::vector<std::unique_ptr<LogEvent>> *events) {

  std::sort(events->begin(), events->end(),

            [](const std::unique_ptr<LogEvent>& a, const std::unique_ptr<LogEvent>& b) {