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

Commit 1f0c5228 authored by Howard Ro's avatar Howard Ro Committed by Android (Google) Code Review
Browse files

Merge "Update libstatssocket/pull API council feedback"

parents 8a6f7056 b26d044a

apex/statsd/tests/libstatspull/jni/stats_pull_helper.cpp

+14 −13
Original line number Diff line number Diff line
@@ -46,15 +46,15 @@ static void init() { 
    }

}



static status_pull_atom_return_t pullAtomCallback(int32_t atomTag, pulled_stats_event_list* data,

static AStatsManager_PullAtomCallbackReturn pullAtomCallback(int32_t atomTag, AStatsEventList* data,

                                                             void* /*cookie*/) {

    sNumPulls++;

    sleep_for(std::chrono::milliseconds(sLatencyMillis));

    for (int i = 0; i < sAtomsPerPull; i++) {

        stats_event* event = add_stats_event_to_pull_data(data);

        stats_event_set_atom_id(event, atomTag);

        stats_event_write_int64(event, (int64_t) sNumPulls);

        stats_event_build(event);

        AStatsEvent* event = AStatsEventList_addStatsEvent(data);

        AStatsEvent_setAtomId(event, atomTag);

        AStatsEvent_writeInt64(event, (int64_t) sNumPulls);

        AStatsEvent_build(event);

    }

    return sPullReturnVal;

}
@@ -71,11 +71,12 @@ Java_com_android_internal_os_statsd_libstats_LibStatsPullTests_registerStatsPull 
    sLatencyMillis = latencyMillis;

    sAtomsPerPull = atomsPerPull;

    sNumPulls = 0;

    pull_atom_metadata metadata = {.cool_down_ns = coolDownNs,

                                   .timeout_ns = timeoutNs,

                                   .additive_fields = nullptr,

                                   .additive_fields_size = 0};

    register_stats_pull_atom_callback(sAtomTag, &pullAtomCallback, &metadata, nullptr);

    AStatsManager_PullAtomMetadata* metadata = AStatsManager_PullAtomMetadata_obtain();

    AStatsManager_PullAtomMetadata_setCoolDownNs(metadata, coolDownNs);

    AStatsManager_PullAtomMetadata_setTimeoutNs(metadata, timeoutNs);



    AStatsManager_registerPullAtomCallback(sAtomTag, &pullAtomCallback, metadata, nullptr);

    AStatsManager_PullAtomMetadata_release(metadata);

}



extern "C"
@@ -83,6 +84,6 @@ JNIEXPORT void JNICALL 
Java_com_android_internal_os_statsd_libstats_LibStatsPullTests_unregisterStatsPuller(

        JNIEnv* /*env*/, jobject /* this */, jint /*atomTag*/)

{

    unregister_stats_pull_atom_callback(sAtomTag);

    AStatsManager_unregisterPullAtomCallback(sAtomTag);

}

} // namespace

apex/statsd/tests/libstatspull/src/com/android/internal/os/statsd/libstats/LibStatsPullTests.java

+0 −1
Original line number Diff line number Diff line
@@ -71,7 +71,6 @@ public class LibStatsPullTests { 
     */

    @Before

    public void setup() {

//        Debug.waitForDebugger();

        mContext = InstrumentationRegistry.getTargetContext();

        assertThat(InstrumentationRegistry.getInstrumentation()).isNotNull();

        sPullReturnValue = StatsManager.PULL_SUCCESS;

cmds/statsd/benchmark/log_event_benchmark.cpp

+6 −6
Original line number Diff line number Diff line
@@ -23,14 +23,14 @@ namespace os { 
namespace statsd {



static size_t createAndParseStatsEvent(uint8_t* msg) {

    struct stats_event* event = stats_event_obtain();

    stats_event_set_atom_id(event, 100);

    stats_event_write_int32(event, 2);

    stats_event_write_float(event, 2.0);

    stats_event_build(event);

    AStatsEvent* event = AStatsEvent_obtain();

    AStatsEvent_setAtomId(event, 100);

    AStatsEvent_writeInt32(event, 2);

    AStatsEvent_writeFloat(event, 2.0);

    AStatsEvent_build(event);



    size_t size;

    uint8_t* buf = stats_event_get_buffer(event, &size);

    uint8_t* buf = AStatsEvent_getBuffer(event, &size);

    memcpy(msg, buf, size);

    return size;

}

cmds/statsd/src/logd/LogEvent.cpp

+28 −0
Original line number Diff line number Diff line
@@ -35,6 +35,34 @@ using android::util::ProtoOutputStream; 
using std::string;

using std::vector;



// stats_event.h socket types. Keep in sync.

/* ERRORS */

#define ERROR_NO_TIMESTAMP 0x1

#define ERROR_NO_ATOM_ID 0x2

#define ERROR_OVERFLOW 0x4

#define ERROR_ATTRIBUTION_CHAIN_TOO_LONG 0x8

#define ERROR_TOO_MANY_KEY_VALUE_PAIRS 0x10

#define ERROR_ANNOTATION_DOES_NOT_FOLLOW_FIELD 0x20

#define ERROR_INVALID_ANNOTATION_ID 0x40

#define ERROR_ANNOTATION_ID_TOO_LARGE 0x80

#define ERROR_TOO_MANY_ANNOTATIONS 0x100

#define ERROR_TOO_MANY_FIELDS 0x200

#define ERROR_INVALID_VALUE_TYPE 0x400

#define ERROR_STRING_NOT_NULL_TERMINATED 0x800



/* TYPE IDS */

#define INT32_TYPE 0x00

#define INT64_TYPE 0x01

#define STRING_TYPE 0x02

#define LIST_TYPE 0x03

#define FLOAT_TYPE 0x04

#define BOOL_TYPE 0x05

#define BYTE_ARRAY_TYPE 0x06

#define OBJECT_TYPE 0x07

#define KEY_VALUE_PAIRS_TYPE 0x08

#define ATTRIBUTION_CHAIN_TYPE 0x09

#define ERROR_TYPE 0x0F



// Msg is expected to begin at the start of the serialized atom -- it should not

// include the android_log_header_t or the StatsEventTag.

LogEvent::LogEvent(uint8_t* msg, uint32_t len, int32_t uid, int32_t pid)

cmds/statsd/tests/LogEvent_test.cpp

+34 −101
Original line number Diff line number Diff line
@@ -46,16 +46,16 @@ Field getField(int32_t tag, const vector<int32_t>& pos, int32_t depth, const vec 
}



TEST(LogEventTest, TestPrimitiveParsing) {

    struct stats_event* event = stats_event_obtain();

    stats_event_set_atom_id(event, 100);

    stats_event_write_int32(event, 10);

    stats_event_write_int64(event, 0x123456789);

    stats_event_write_float(event, 2.0);

    stats_event_write_bool(event, true);

    stats_event_build(event);

    AStatsEvent* event = AStatsEvent_obtain();

    AStatsEvent_setAtomId(event, 100);

    AStatsEvent_writeInt32(event, 10);

    AStatsEvent_writeInt64(event, 0x123456789);

    AStatsEvent_writeFloat(event, 2.0);

    AStatsEvent_writeBool(event, true);

    AStatsEvent_build(event);



    size_t size;

    uint8_t* buf = stats_event_get_buffer(event, &size);

    uint8_t* buf = AStatsEvent_getBuffer(event, &size);



    LogEvent logEvent(buf, size, /*uid=*/ 1000, /*pid=*/ 1001);

    EXPECT_TRUE(logEvent.isValid());
@@ -90,20 +90,20 @@ TEST(LogEventTest, TestPrimitiveParsing) { 
    EXPECT_EQ(Type::INT, boolItem.mValue.getType()); // FieldValue does not support boolean type

    EXPECT_EQ(1, boolItem.mValue.int_value);



    stats_event_release(event);

    AStatsEvent_release(event);

}





TEST(LogEventTest, TestStringAndByteArrayParsing) {

    struct stats_event* event = stats_event_obtain();

    stats_event_set_atom_id(event, 100);

    AStatsEvent* event = AStatsEvent_obtain();

    AStatsEvent_setAtomId(event, 100);

    string str = "test";

    stats_event_write_string8(event, str.c_str());

    stats_event_write_byte_array(event, (uint8_t*)str.c_str(), str.length());

    stats_event_build(event);

    AStatsEvent_writeString(event, str.c_str());

    AStatsEvent_writeByteArray(event, (uint8_t*)str.c_str(), str.length());

    AStatsEvent_build(event);



    size_t size;

    uint8_t* buf = stats_event_get_buffer(event, &size);

    uint8_t* buf = AStatsEvent_getBuffer(event, &size);



    LogEvent logEvent(buf, size, /*uid=*/ 1000, /*pid=*/ 1001);

    EXPECT_TRUE(logEvent.isValid());
@@ -127,18 +127,18 @@ TEST(LogEventTest, TestStringAndByteArrayParsing) { 
    vector<uint8_t> expectedValue = {'t', 'e', 's', 't'};

    EXPECT_EQ(expectedValue, storageItem.mValue.storage_value);



    stats_event_release(event);

    AStatsEvent_release(event);

}



TEST(LogEventTest, TestEmptyString) {

    struct stats_event* event = stats_event_obtain();

    stats_event_set_atom_id(event, 100);

    AStatsEvent* event = AStatsEvent_obtain();

    AStatsEvent_setAtomId(event, 100);

    string empty = "";

    stats_event_write_string8(event, empty.c_str());

    stats_event_build(event);

    AStatsEvent_writeString(event, empty.c_str());

    AStatsEvent_build(event);



    size_t size;

    uint8_t* buf = stats_event_get_buffer(event, &size);

    uint8_t* buf = AStatsEvent_getBuffer(event, &size);



    LogEvent logEvent(buf, size, /*uid=*/ 1000, /*pid=*/ 1001);

    EXPECT_TRUE(logEvent.isValid());
@@ -155,18 +155,18 @@ TEST(LogEventTest, TestEmptyString) { 
    EXPECT_EQ(Type::STRING, item.mValue.getType());

    EXPECT_EQ(empty, item.mValue.str_value);



    stats_event_release(event);

    AStatsEvent_release(event);

}



TEST(LogEventTest, TestByteArrayWithNullCharacter) {

    struct stats_event* event = stats_event_obtain();

    stats_event_set_atom_id(event, 100);

    AStatsEvent* event = AStatsEvent_obtain();

    AStatsEvent_setAtomId(event, 100);

    uint8_t message[] = {'\t', 'e', '\0', 's', 't'};

    stats_event_write_byte_array(event, message, 5);

    stats_event_build(event);

    AStatsEvent_writeByteArray(event, message, 5);

    AStatsEvent_build(event);



    size_t size;

    uint8_t* buf = stats_event_get_buffer(event, &size);

    uint8_t* buf = AStatsEvent_getBuffer(event, &size);



    LogEvent logEvent(buf, size, /*uid=*/ 1000, /*pid=*/ 1001);

    EXPECT_TRUE(logEvent.isValid());
@@ -184,79 +184,12 @@ TEST(LogEventTest, TestByteArrayWithNullCharacter) { 
    vector<uint8_t> expectedValue(message, message + 5);

    EXPECT_EQ(expectedValue, item.mValue.storage_value);



    stats_event_release(event);

}



TEST(LogEventTest, TestKeyValuePairs) {

    struct stats_event* event = stats_event_obtain();

    stats_event_set_atom_id(event, 100);



    struct key_value_pair pairs[4];

    pairs[0] = {.key = 0, .valueType = INT32_TYPE, .int32Value = 1};

    pairs[1] = {.key = 1, .valueType = INT64_TYPE, .int64Value = 0x123456789};

    pairs[2] = {.key = 2, .valueType = FLOAT_TYPE, .floatValue = 2.0};

    string str = "test";

    pairs[3] = {.key = 3, .valueType = STRING_TYPE, .stringValue = str.c_str()};



    stats_event_write_key_value_pairs(event, pairs, 4);

    stats_event_build(event);



    size_t size;

    uint8_t* buf = stats_event_get_buffer(event, &size);



    LogEvent logEvent(buf, size, /*uid=*/ 1000, /*pid=*/ 1001);

    EXPECT_TRUE(logEvent.isValid());

    EXPECT_EQ(100, logEvent.GetTagId());

    EXPECT_EQ(1000, logEvent.GetUid());

    EXPECT_EQ(1001, logEvent.GetPid());



    const vector<FieldValue>& values = logEvent.getValues();

    EXPECT_EQ(8, values.size()); // 2 FieldValues per key-value pair



    // Check the keys first

    for (int i = 0; i < values.size() / 2; i++) {

        const FieldValue& item = values[2 * i];

        int32_t depth1Pos = i + 1;

        bool depth1Last = i == (values.size() / 2 - 1);

        Field expectedField = getField(100, {1, depth1Pos, 1}, 2, {true, depth1Last, false});



        EXPECT_EQ(expectedField, item.mField);

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

        EXPECT_EQ(i, item.mValue.int_value);

    }



    // Check the values now

    // Note: pos[2] = index of type in KeyValuePair in atoms.proto

    const FieldValue& int32Item = values[1];

    Field expectedField = getField(100, {1, 1, 2}, 2, {true, false, true});

    EXPECT_EQ(expectedField, int32Item.mField);

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

    EXPECT_EQ(1, int32Item.mValue.int_value);



    const FieldValue& int64Item = values[3];

    expectedField = getField(100, {1, 2, 3}, 2, {true, false, true});

    EXPECT_EQ(expectedField, int64Item.mField);

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

    EXPECT_EQ(0x123456789, int64Item.mValue.long_value);



    const FieldValue& floatItem = values[5];

    expectedField = getField(100, {1, 3, 5}, 2, {true, false, true});

    EXPECT_EQ(expectedField, floatItem.mField);

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

    EXPECT_EQ(2.0, floatItem.mValue.float_value);



    const FieldValue& stringItem = values[7];

    expectedField = getField(100, {1, 4, 4}, 2, {true, true, true});

    EXPECT_EQ(expectedField, stringItem.mField);

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

    EXPECT_EQ(str, stringItem.mValue.str_value);



    stats_event_release(event);

    AStatsEvent_release(event);

}



TEST(LogEventTest, TestAttributionChain) {

    struct stats_event* event = stats_event_obtain();

    stats_event_set_atom_id(event, 100);

    AStatsEvent* event = AStatsEvent_obtain();

    AStatsEvent_setAtomId(event, 100);



    string tag1 = "tag1";

    string tag2 = "tag2";
@@ -264,11 +197,11 @@ TEST(LogEventTest, TestAttributionChain) { 
    uint32_t uids[] = {1001, 1002};

    const char* tags[] = {tag1.c_str(), tag2.c_str()};



    stats_event_write_attribution_chain(event, uids, tags, 2);

    stats_event_build(event);

    AStatsEvent_writeAttributionChain(event, uids, tags, 2);

    AStatsEvent_build(event);



    size_t size;

    uint8_t* buf = stats_event_get_buffer(event, &size);

    uint8_t* buf = AStatsEvent_getBuffer(event, &size);



    LogEvent logEvent(buf, size, /*uid=*/ 1000, /*pid=*/ 1001);

    EXPECT_TRUE(logEvent.isValid());
@@ -305,7 +238,7 @@ TEST(LogEventTest, TestAttributionChain) { 
    EXPECT_EQ(Type::STRING, tag2Item.mValue.getType());

    EXPECT_EQ(tag2, tag2Item.mValue.str_value);



    stats_event_release(event);

    AStatsEvent_release(event);

}



#else // NEW_ENCODING_SCHEME