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

Commit f7bc6ab7 authored by Yao Chen's avatar Yao Chen
Browse files

Allow StatsLog to directly write to statsd's socket. 

+ Reuse the log_event_list from liblog. StatsLog's binary format remains unchanged
+ Copied socket write code from liblog, including the retry logic.
+ Added build flags to control the StatsLog channel (logd, statsd, or both for debugging)

Bug: 78239479
Test: locally tested and saw logs being written to statsd

Change-Id: I7b1f0069ead00bbf3c29e4bd5b7f363a7ce26abe
parent 46e58e1b

cmds/statsd/statsd.rc

+1 −0
Original line number Diff line number Diff line
@@ -14,6 +14,7 @@ 


service statsd /system/bin/statsd

    class main

    socket statsdw dgram+passcred 0222 statsd statsd

    user statsd

    group statsd log

    writepid /dev/cpuset/system-background/tasks

tools/stats_log_api_gen/Android.bp

+7 −0
Original line number Diff line number Diff line
@@ -98,9 +98,16 @@ cc_library_shared { 
    name: "libstatslog",

    generated_sources: ["statslog.cpp"],

    generated_headers: ["statslog.h"],

    srcs: [

        "stats_event_list.cpp",

        "statsd_writer.cpp",

    ],

    cflags: [

        "-Wall",

        "-Werror",

        "-DLIBLOG_LOG_TAG=1006",

        "-DWRITE_TO_STATSD=1",

        "-DWRITE_TO_LOGD=0",

    ],

    export_generated_headers: ["statslog.h"],

    shared_libs: [

tools/stats_log_api_gen/main.cpp

+3 −3
Original line number Diff line number Diff line
@@ -104,7 +104,7 @@ static int write_stats_log_cpp(FILE *out, const Atoms &atoms, 
    fprintf(out, "#include <mutex>\n");

    fprintf(out, "#include <chrono>\n");

    fprintf(out, "#include <thread>\n");

    fprintf(out, "#include <log/log_event_list.h>\n");

    fprintf(out, "#include <stats_event_list.h>\n");

    fprintf(out, "#include <log/log.h>\n");

    fprintf(out, "#include <statslog.h>\n");

    fprintf(out, "#include <utils/SystemClock.h>\n");
@@ -242,7 +242,7 @@ static int write_stats_log_cpp(FILE *out, const Atoms &atoms, 


        fprintf(out, "{\n");

        argIndex = 1;

        fprintf(out, "    android_log_event_list event(kStatsEventTag);\n");

        fprintf(out, "    stats_event_list event(kStatsEventTag);\n");

        fprintf(out, "    event << android::elapsedRealtimeNano();\n\n");

        fprintf(out, "    event << code;\n\n");

        for (vector<java_type_t>::const_iterator arg = signature->begin();
@@ -375,7 +375,7 @@ static int write_stats_log_cpp(FILE *out, const Atoms &atoms, 


        fprintf(out, "{\n");

        argIndex = 1;

        fprintf(out, "    android_log_event_list event(kStatsEventTag);\n");

        fprintf(out, "    stats_event_list event(kStatsEventTag);\n");

        fprintf(out, "    event << android::elapsedRealtimeNano();\n\n");

        fprintf(out, "    event << code;\n\n");

        for (vector<java_type_t>::const_iterator arg = signature->begin();

tools/stats_log_api_gen/stats_event_list.cpp

0 → 100644
+165 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2018, The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include "stats_event_list.h"



#include "statsd_writer.h"



namespace android {

namespace util {



enum ReadWriteFlag {

    kAndroidLoggerRead = 1,

    kAndroidLoggerWrite = 2,

};



typedef struct {

    uint32_t tag;

    unsigned pos; /* Read/write position into buffer */

    unsigned count[ANDROID_MAX_LIST_NEST_DEPTH + 1]; /* Number of elements   */

    unsigned list[ANDROID_MAX_LIST_NEST_DEPTH + 1];  /* pos for list counter */

    unsigned list_nest_depth;

    unsigned len; /* Length or raw buffer. */

    bool overflow;

    bool list_stop; /* next call decrement list_nest_depth and issue a stop */

    ReadWriteFlag read_write_flag;

    uint8_t storage[LOGGER_ENTRY_MAX_PAYLOAD];

} android_log_context_internal;



extern struct android_log_transport_write statsdLoggerWrite;



static int __write_to_statsd_init(struct iovec* vec, size_t nr);

static int (*write_to_statsd)(struct iovec* vec,

                              size_t nr) = __write_to_statsd_init;



int stats_write_list(android_log_context ctx) {

    android_log_context_internal* context;

    const char* msg;

    ssize_t len;



    context = (android_log_context_internal*)(ctx);

    if (!context || (kAndroidLoggerWrite != context->read_write_flag)) {

        return -EBADF;

    }



    if (context->list_nest_depth) {

        return -EIO;

    }



    /* NB: if there was overflow, then log is truncated. Nothing reported */

    context->storage[1] = context->count[0];

    len = context->len = context->pos;

    msg = (const char*)context->storage;

    /* it's not a list */

    if (context->count[0] <= 1) {

        len -= sizeof(uint8_t) + sizeof(uint8_t);

        if (len < 0) {

            len = 0;

        }

        msg += sizeof(uint8_t) + sizeof(uint8_t);

    }



    struct iovec vec[2];

    vec[0].iov_base = &context->tag;

    vec[0].iov_len = sizeof(context->tag);

    vec[1].iov_base = (void*)msg;

    vec[1].iov_len = len;

    return write_to_statsd(vec, 2);

}



int stats_event_list::write_to_logger(android_log_context ctx, log_id_t id) {

    int retValue = 0;



    if (WRITE_TO_LOGD) {

        retValue = android_log_write_list(ctx, id);

    }



    if (WRITE_TO_STATSD) {

        // log_event_list's cast operator is overloaded.

        int ret = stats_write_list(static_cast<android_log_context>(*this));

        // In debugging phase, we may write to both logd and statsd. Prefer to return

        // statsd socket write error code here.

        if (ret < 0) {

            retValue = ret;

        }

    }



    return retValue;

}



/* log_init_lock assumed */

static int __write_to_statsd_initialize_locked() {

    if (!statsdLoggerWrite.open || ((*statsdLoggerWrite.open)() < 0)) {

        if (statsdLoggerWrite.close) {

            (*statsdLoggerWrite.close)();

            return -ENODEV;

        }

    }

    return 1;

}



static int __write_to_stats_daemon(struct iovec* vec, size_t nr) {

    int ret, save_errno;

    struct timespec ts;

    size_t len, i;



    for (len = i = 0; i < nr; ++i) {

        len += vec[i].iov_len;

    }

    if (!len) {

        return -EINVAL;

    }



    save_errno = errno;

    clock_gettime(CLOCK_REALTIME, &ts);



    ret = 0;



    ssize_t retval;

    retval = (*statsdLoggerWrite.write)(&ts, vec, nr);

    if (ret >= 0) {

        ret = retval;

    }



    errno = save_errno;

    return ret;

}



static int __write_to_statsd_init(struct iovec* vec, size_t nr) {

    int ret, save_errno = errno;



    statsd_writer_init_lock();



    if (write_to_statsd == __write_to_statsd_init) {

        ret = __write_to_statsd_initialize_locked();

        if (ret < 0) {

            statsd_writer_init_unlock();

            errno = save_errno;

            return ret;

        }



        write_to_statsd = __write_to_stats_daemon;

    }



    statsd_writer_init_unlock();



    ret = write_to_statsd(vec, nr);

    errno = save_errno;

    return ret;

}



}  // namespace util

}  // namespace android
 
 No newline at end of file

tools/stats_log_api_gen/stats_event_list.h

0 → 100644
+219 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2018, The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#ifndef ANDROID_STATS_LOG_STATS_EVENT_LIST_H

#define ANDROID_STATS_LOG_STATS_EVENT_LIST_H



#include <log/log_event_list.h>



namespace android {

namespace util {



/**

 * A copy of android_log_event_list class.

 *

 * android_log_event_list is going to be deprecated soon, so copy it here to avoid creating

 * dependency on upstream code. TODO(b/78304629): Rewrite this code.

 */

class stats_event_list {

private:

    android_log_context ctx;

    int ret;



    stats_event_list(const stats_event_list&) = delete;

    void operator=(const stats_event_list&) = delete;



    int write_to_logger(android_log_context context, log_id_t id);



public:

    explicit stats_event_list(int tag) : ret(0) {

        ctx = create_android_logger(static_cast<uint32_t>(tag));

    }

    explicit stats_event_list(log_msg& log_msg) : ret(0) {

        ctx = create_android_log_parser(log_msg.msg() + sizeof(uint32_t),

                                        log_msg.entry.len - sizeof(uint32_t));

    }

    ~stats_event_list() {

        android_log_destroy(&ctx);

    }



    int close() {

        int retval = android_log_destroy(&ctx);

        if (retval < 0) ret = retval;

        return retval;

    }



    /* To allow above C calls to use this class as parameter */

    operator android_log_context() const {

        return ctx;

    }



    /* return errors or transmit status */

    int status() const {

        return ret;

    }



    int begin() {

        int retval = android_log_write_list_begin(ctx);

        if (retval < 0) ret = retval;

        return ret;

    }

    int end() {

        int retval = android_log_write_list_end(ctx);

        if (retval < 0) ret = retval;

        return ret;

    }



    stats_event_list& operator<<(int32_t value) {

        int retval = android_log_write_int32(ctx, value);

        if (retval < 0) ret = retval;

        return *this;

    }



    stats_event_list& operator<<(uint32_t value) {

        int retval = android_log_write_int32(ctx, static_cast<int32_t>(value));

        if (retval < 0) ret = retval;

        return *this;

    }



    stats_event_list& operator<<(bool value) {

        int retval = android_log_write_int32(ctx, value ? 1 : 0);

        if (retval < 0) ret = retval;

        return *this;

    }



    stats_event_list& operator<<(int64_t value) {

        int retval = android_log_write_int64(ctx, value);

        if (retval < 0) ret = retval;

        return *this;

    }



    stats_event_list& operator<<(uint64_t value) {

        int retval = android_log_write_int64(ctx, static_cast<int64_t>(value));

        if (retval < 0) ret = retval;

        return *this;

    }



    stats_event_list& operator<<(const char* value) {

        int retval = android_log_write_string8(ctx, value);

        if (retval < 0) ret = retval;

        return *this;

    }



#if defined(_USING_LIBCXX)

    stats_event_list& operator<<(const std::string& value) {

        int retval = android_log_write_string8_len(ctx, value.data(), value.length());

        if (retval < 0) ret = retval;

        return *this;

    }

#endif



    stats_event_list& operator<<(float value) {

        int retval = android_log_write_float32(ctx, value);

        if (retval < 0) ret = retval;

        return *this;

    }



    int write(log_id_t id = LOG_ID_EVENTS) {

        /* facilitate -EBUSY retry */

        if ((ret == -EBUSY) || (ret > 0)) ret = 0;

        int retval = write_to_logger(ctx, id);

        /* existing errors trump transmission errors */

        if (!ret) ret = retval;

        return ret;

    }



    int operator<<(log_id_t id) {

        write(id);

        android_log_destroy(&ctx);

        return ret;

    }



    /*

     * Append<Type> methods removes any integer promotion

     * confusion, and adds access to string with length.

     * Append methods are also added for all types for

     * convenience.

     */



    bool AppendInt(int32_t value) {

        int retval = android_log_write_int32(ctx, value);

        if (retval < 0) ret = retval;

        return ret >= 0;

    }



    bool AppendLong(int64_t value) {

        int retval = android_log_write_int64(ctx, value);

        if (retval < 0) ret = retval;

        return ret >= 0;

    }



    bool AppendString(const char* value) {

        int retval = android_log_write_string8(ctx, value);

        if (retval < 0) ret = retval;

        return ret >= 0;

    }



    bool AppendString(const char* value, size_t len) {

        int retval = android_log_write_string8_len(ctx, value, len);

        if (retval < 0) ret = retval;

        return ret >= 0;

    }



#if defined(_USING_LIBCXX)

    bool AppendString(const std::string& value) {

        int retval = android_log_write_string8_len(ctx, value.data(), value.length());

        if (retval < 0) ret = retval;

        return ret;

    }



    bool Append(const std::string& value) {

        int retval = android_log_write_string8_len(ctx, value.data(), value.length());

        if (retval < 0) ret = retval;

        return ret;

    }

#endif



    bool AppendFloat(float value) {

        int retval = android_log_write_float32(ctx, value);

        if (retval < 0) ret = retval;

        return ret >= 0;

    }



    template <typename Tvalue>

    bool Append(Tvalue value) {

        *this << value;

        return ret >= 0;

    }



    bool Append(const char* value, size_t len) {

        int retval = android_log_write_string8_len(ctx, value, len);

        if (retval < 0) ret = retval;

        return ret >= 0;

    }



    android_log_list_element read() {

        return android_log_read_next(ctx);

    }

    android_log_list_element peek() {

        return android_log_peek_next(ctx);

    }

};



}  // namespace util

}  // namespace android



#endif  // ANDROID_STATS_LOG_STATS_EVENT_LIST_H