From 06aab08d40243adb3a7c3fb4a19060c4d2197a9a Mon Sep 17 00:00:00 2001 From: "liu.mingyi" <27064129+eeliu@users.noreply.github.com> Date: Mon, 18 Sep 2023 10:14:14 +0800 Subject: [PATCH] add clang-format --- .devcontainer/Dockerfile | 6 +- .devcontainer/devcontainer.json | 7 +- common/include/common.h.in | 174 ++-- common/src/Cache/Chunk.cpp | 368 ++++---- common/src/Cache/NodeTreeWriter.cpp | 10 +- common/src/Cache/SafeSharedState.cpp | 71 +- .../src/ConnectionPool/SpanConnectionPool.cpp | 120 ++- common/src/ConnectionPool/TransLayer.cpp | 374 ++++---- common/src/Context/ContextType.cpp | 10 +- common/src/NodePool/PoolManager.cpp | 250 +++--- common/src/NodePool/PoolManager.h | 195 ++--- common/src/NodePool/TraceNode.cpp | 227 +++-- common/src/NodePool/TraceNode.h | 517 ++++++----- common/src/Util/Helper.cpp | 141 ++- common/src/common.cpp | 810 +++++++----------- common/test/test_chunk.cc | 87 +- common/test/test_common.cc | 258 +++--- common/test/test_genUniqId.cc | 58 +- common/test/test_main.cpp | 13 +- common/test/test_node.cc | 580 ++++++------- common/test/test_node_pool.cc | 76 +- common/test/test_trans_layer.cc | 169 ++-- common/test/test_util.cc | 161 ++-- src/PHP/pinpoint_php.cpp | 753 ++++++++-------- 24 files changed, 2431 insertions(+), 3004 deletions(-) diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile index fa80ed082..0ffea0404 100644 --- a/.devcontainer/Dockerfile +++ b/.devcontainer/Dockerfile @@ -4,7 +4,7 @@ ENV TZ=Asia/Shanghai ENV LC_CTYPE=en_US.UTF-8 ENV LC_ALL=en_US.UTF-8 RUN ln -snf /usr/share/zoneinfo/$TZ /etc/localtime && echo $TZ > /etc/timezone -RUN apt update && apt install -y gcc g++ gdb pkg-config libxml2-dev libsqlite3-dev libcurl4-openssl-dev zlib1g-dev make cmake wget autoconf git +RUN apt update && apt install -y gcc g++ gdb pkg-config libxml2-dev libsqlite3-dev libcurl4-openssl-dev zlib1g-dev make cmake wget autoconf git clangd ## enable php-7.4 ENV PHP_VESION=php-7.4.33 RUN cd ~ && wget https://www.php.net/distributions/${PHP_VESION}.tar.gz && tar xvf ${PHP_VESION}.tar.gz && cd ${PHP_VESION} && ./configure --prefix=/opt/${PHP_VESION} --enable-fpm --enable-opcache --enable-debug && make -j && make install @@ -13,11 +13,11 @@ COPY php.ini /opt/ ### Build php module ### curl -RUN cd ~/${PHP_VESION}/ext/curl && phpize && ./configure && make -j && make install +# RUN cd ~/${PHP_VESION}/ext/curl && phpize && ./configure && make -j && make install ### mysqli # RUN cd ~/php-7.4.33/ext/mysqli && phpize && ./configure && make -j && make install ### pdo -RUN cd ~/${PHP_VESION}/ext/pdo && phpize && ./configure && make -j && make install +# RUN cd ~/${PHP_VESION}/ext/pdo && phpize && ./configure && make -j && make install ENV PHP_VESION=php-5.6.30 RUN cd ~ && wget https://www.php.net/distributions/${PHP_VESION}.tar.gz && tar xvf ${PHP_VESION}.tar.gz && cd ${PHP_VESION} && ./configure --prefix=/opt/${PHP_VESION} --enable-fpm --enable-opcache --enable-debug && make -j && make install diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json index 0eb3b9e1e..a5cefc255 100644 --- a/.devcontainer/devcontainer.json +++ b/.devcontainer/devcontainer.json @@ -36,14 +36,15 @@ // }, // "remoteUser": "vscode", // "containerUser": "vscode", - // "postCreateCommand": ".devcontainer/setup.sh", + "postCreateCommand": ".devcontainer/setup.sh", "extensions": [ "github.vscode-pull-request-github", "zxh404.vscode-proto3", - "bazelbuild.vscode-bazel", "llvm-vs-code-extensions.vscode-clangd", "vadimcn.vscode-lldb", "webfreak.debug", - "ms-python.python" + "ms-python.python", + "xaver.clang-format", + "zxh404.vscode-proto3" ] } \ No newline at end of file diff --git a/common/include/common.h.in b/common/include/common.h.in index 88d3209eb..69b2af722 100644 --- a/common/include/common.h.in +++ b/common/include/common.h.in @@ -34,78 +34,55 @@ #define IN_MSG_BUF_SIZE 4096 #define NAMING_SIZE 128 static const int RECONNECT_TIME_SEC = 5; -typedef enum -{ - RESPONSE_AGENT_INFO = 0, - REQ_UPDATE_SPAN = 1 -} MSG_TYPE; +typedef enum { RESPONSE_AGENT_INFO = 0, REQ_UPDATE_SPAN = 1 } MSG_TYPE; -typedef enum -{ - E_LOGGING = 0x1, - E_DISABLE_GIL = 0x2, // disable gil checking in python - E_UTEST = 0x4 +typedef enum { + E_LOGGING = 0x1, + E_DISABLE_GIL = 0x2, // disable gil checking in python + E_UTEST = 0x4 } AGENT_FLAG; -typedef enum -{ - E_INVALID_NODE = -1, - E_ROOT_NODE = 0 -} NodeID; +typedef enum { E_INVALID_NODE = -1, E_ROOT_NODE = 0 } NodeID; #pragma pack(1) -typedef struct -{ - uint32_t type; - uint32_t length; +typedef struct { + uint32_t type; + uint32_t length; } Header; #pragma pack() -typedef struct collector_agent_s -{ - uint64_t start_time; - char *appid; - char *appname; +typedef struct collector_agent_s { + uint64_t start_time; + char *appid; + char *appname; } CollectorAgentInfo; /// -typedef struct trace_store_layer -{ - void (*set_cur_trace_cb)(void *); - void *(*get_cur_trace_cb)(void); +typedef struct trace_store_layer { + void (*set_cur_trace_cb)(void *); + void *(*get_cur_trace_cb)(void); } TraceStoreLayer; #define LOG_SIZE 4096 #define MAX_ADDRESS_SIZE 256 typedef void (*VOID_FUNC)(void); -typedef struct pp_agent_s -{ - char co_host[MAX_ADDRESS_SIZE]; // tcp:ip:port should support dns - long timeout_ms; // always be 0 - long trace_limit; // change to long as python need long - int agent_type; - uint8_t inter_flag; - VOID_FUNC get_read_lock; - VOID_FUNC get_write_lock; - VOID_FUNC release_lock; +typedef struct pp_agent_s { + char co_host[MAX_ADDRESS_SIZE]; // tcp:ip:port should support dns + long timeout_ms; // always be 0 + long trace_limit; // change to long as python need long + int agent_type; + uint8_t inter_flag; + VOID_FUNC get_read_lock; + VOID_FUNC get_write_lock; + VOID_FUNC release_lock; } PPAgentT; -typedef enum -{ - E_OFFLINE = 0x1, - E_TRACE_PASS = 0x2, - E_TRACE_BLOCK = 0x4, - E_READY = 0x8 -} E_AGENT_STATUS; +typedef enum { E_OFFLINE = 0x1, E_TRACE_PASS = 0x2, E_TRACE_BLOCK = 0x4, E_READY = 0x8 } E_AGENT_STATUS; /** * @brief at present only root checking */ -typedef enum -{ - E_LOC_CURRENT = 0x0, - E_LOC_ROOT = 0x1 -} E_NODE_LOC; +typedef enum { E_LOC_CURRENT = 0x0, E_LOC_ROOT = 0x1 } E_NODE_LOC; #define PINPOINT_C_AGENT_API_VERSION "@PROJECT_VERSION@" @@ -121,31 +98,30 @@ typedef enum * - add tls */ #ifdef __cplusplus -extern "C" -{ +extern "C" { #endif - extern PPAgentT global_agent_info; +extern PPAgentT global_agent_info; - /** +/** * @brief [tls] * pinpoint_get_per_thread_id and pinpoint_update_per_thread_id are paired API * pinpoint_get_per_thread_id get the current trace-id of current thread * pinpoint_update_per_thread_id update(stores) the current trace-id for pinpoint_get_per_thread_id * @return NodeID */ - NodeID pinpoint_get_per_thread_id(void); - void pinpoint_update_per_thread_id(NodeID id); +NodeID pinpoint_get_per_thread_id(void); +void pinpoint_update_per_thread_id(NodeID id); - /** +/** * @brief [tls] start a trace (span) from parentId. if current span is empty, create a span or else create a spanevent * * @param parentId * @return -1: failed new traceId related to parentId (caller [parentId] -> callee [NodeID] ) */ - NodeID pinpoint_start_trace(NodeID parentId); +NodeID pinpoint_start_trace(NodeID parentId); - /** +/** * @brief [tls] V1 support trace with optional config * Not support on root traceNode * @param parentId @@ -156,67 +132,67 @@ extern "C" * "TraceOnlyException" // only trace exception( only report when call pinpoint_add_exception) * @return NodeID */ - NodeID pinpoint_start_traceV1(NodeID parentId, const char *opt, ...); +NodeID pinpoint_start_traceV1(NodeID parentId, const char *opt, ...); - void pinpoint_add_exception(NodeID, const char *exp); +void pinpoint_add_exception(NodeID, const char *exp); - /**[tls] +/**[tls] * the same as pinpoint_start_trace. BUT, end a span or a spanevent * Note: pinpoint_end_trace is thread safe, but you should avoid to call it in the multi-thread, it may send duplicate trace span * @return NodeID is parent node id */ - NodeID pinpoint_end_trace(NodeID); +NodeID pinpoint_end_trace(NodeID); - /** +/** * @brief wake a finished trace: this trace get a new startime, so it could be profile again. the end_trace will update the ["e"] by cumulative time (NOTE: root trace not supported) * * @param traceId * @return int 0 if success, -1 if failed */ - int pinpoint_wake_trace(NodeID traceId); +int pinpoint_wake_trace(NodeID traceId); - /** +/** * check id->traceNode is root * @param * @return 1: is root; 0: not root node;-1: A wrong id */ - int pinpoint_trace_is_root(NodeID); +int pinpoint_trace_is_root(NodeID); - /** +/** * force end current trace, only called when callstack leaked * @return int 0 : means oK * -1: exception found, check the log */ - int pinpoint_force_end_trace(NodeID, int32_t timeout); +int pinpoint_force_end_trace(NodeID, int32_t timeout); - /** +/** * [tls] pinpoint_add_clues, append a value into span[key] * @param key must be a string * @param value key must be a string */ - void pinpoint_add_clues(NodeID _id, const char *key, const char *value, E_NODE_LOC flag); - /** +void pinpoint_add_clues(NodeID _id, const char *key, const char *value, E_NODE_LOC flag); +/** * [tls] pinpoint_add_clues, add a key-value into span. span[key]=value * @param key must be a string * @param value key must be a string */ - void pinpoint_add_clue(NodeID _id, const char *key, const char *value, E_NODE_LOC flag); - /** +void pinpoint_add_clue(NodeID _id, const char *key, const char *value, E_NODE_LOC flag); +/** * [tls] add a key value into current trace. IF the trace is end, all data(key-value) will be free * @param key * @param value */ - void pinpoint_set_context_key(NodeID _id, const char *key, const char *value); - /** +void pinpoint_set_context_key(NodeID _id, const char *key, const char *value); +/** * [tls] get the corresponding value with key(in current trace) * @param size copy into pbuf, not include '\0' * @return */ - int pinpoint_get_context_key(NodeID _id, const char *key, char *pbuf, int buf_size); +int pinpoint_get_context_key(NodeID _id, const char *key, char *pbuf, int buf_size); - void pinpoint_set_context_long(NodeID _id, const char *key, long); +void pinpoint_set_context_long(NodeID _id, const char *key, long); - /** +/** * @brief the value is a long type * * @param _id node id @@ -224,15 +200,15 @@ extern "C" * @return int 1: failed * 0: success */ - int pinpoint_get_context_long(NodeID _id, const char *key, long *); - /** +int pinpoint_get_context_long(NodeID _id, const char *key, long *); +/** * [tls] if tracelimit enable, check current trace state, * @param timestamp * @return 0, sampled or else, not sampled */ - int check_tracelimit(int64_t); +int check_tracelimit(int64_t); - /** +/** * @brief [tls] setting current trace status typedef enum { E_OFFLINE = 0x1, @@ -244,45 +220,45 @@ extern "C" * @param status * @return int last status */ - uint64_t mark_current_trace_status(NodeID _id, int status); +uint64_t mark_current_trace_status(NodeID _id, int status); - /** +/** * [tls] get an unique auto-increment id * NOTE: implement by shared memory, only valid in current host. * @return */ - int64_t generate_unique_id(void); +int64_t generate_unique_id(void); - /** +/** * [tls] get the start time of collector-agent.Use to generate transactionID * @return */ - uint64_t pinpoint_start_time(void); +uint64_t pinpoint_start_time(void); - /** +/** * mark current span with error * @param msg * @param error_filename * @param error_lineno */ - void catch_error(NodeID _id, const char *msg, const char *error_filename, uint32_t error_lineno); - typedef void (*log_msg_cb)(char *); - void register_error_cb(log_msg_cb error_cb); +void catch_error(NodeID _id, const char *msg, const char *error_filename, uint32_t error_lineno); +typedef void (*log_msg_cb)(char *); +void register_error_cb(log_msg_cb error_cb); - /** +/** * @brief for test-case: not send span to collector-agent, pass to handler * not tls * @param handler */ - void register_span_handler(void (*handler)(const char *)); +void register_span_handler(void (*handler)(const char *)); - void pp_trace(const char *format, ...); - /** +void pp_trace(const char *format, ...); +/** * NOTE: only for testcase */ - void reset_unique_id(void); - const char *pinpoint_agent_version(); - void show_status(void); +void reset_unique_id(void); +const char *pinpoint_agent_version(); +void show_status(void); #ifdef __cplusplus } #endif diff --git a/common/src/Cache/Chunk.cpp b/common/src/Cache/Chunk.cpp index f7ace8071..9eedbac81 100644 --- a/common/src/Cache/Chunk.cpp +++ b/common/src/Cache/Chunk.cpp @@ -20,278 +20,224 @@ * Author: eeliu */ #include "Chunk.h" -namespace Cache{ - +namespace Cache +{ int Chunks::copyDataIntoReadyCK(const void* data, uint32_t length) { - if (ready_cks.empty()) - { - return length; - } - - Chunk* ck = ready_cks.back(); - - char* p_ck_r = &ck->data[ck->r_ofs]; - uint32_t capacity = ck->block_size - ck->r_ofs; - if (capacity >= length) - { - memcpy(p_ck_r, data, length); - ck->r_ofs += length; - length = 0; - } - else if (capacity > 0) // capacity < length - { // current ck is full - memcpy(p_ck_r, data, capacity); - length -= capacity; - ck->r_ofs += capacity; - } - - return length; + if (ready_cks.empty()) { return length; } + + Chunk* ck = ready_cks.back(); + + char* p_ck_r = &ck->data[ck->r_ofs]; + uint32_t capacity = ck->block_size - ck->r_ofs; + if (capacity >= length) { + memcpy(p_ck_r, data, length); + ck->r_ofs += length; + length = 0; + } else if (capacity > 0) // capacity < length + { // current ck is full + memcpy(p_ck_r, data, capacity); + length -= capacity; + ck->r_ofs += capacity; + } + + return length; } -int Chunks::copyDataIntoFreeCK(const void*data, uint32_t length) +int Chunks::copyDataIntoFreeCK(const void* data, uint32_t length) { - if (this->free_cks.empty()) - { - return length; - } + if (this->free_cks.empty()) { return length; } - iter = this->free_cks.begin(); + iter = this->free_cks.begin(); - while (iter != this->free_cks.end() && length >0 ) - { - Chunk* ck = *iter; - iter++; - char* f_buf_start = &ck->data[ck->r_ofs]; - uint32_t ck_capacity = ck->block_size - ck->r_ofs; - if (ck_capacity >= length) - { - // current data task is done - memcpy(f_buf_start, data, length); - ck->r_ofs += length; - length = 0; - - } - else if (ck_capacity > 0) //ck_capacity < length - { - memcpy(f_buf_start, data, ck_capacity); - length -= ck_capacity; - data = (const char*) data + ck_capacity; - ck->r_ofs += ck_capacity; - } - - this->ck_free_ck_capacity -= ck->block_size; - // remove free in flist - this->free_cks.pop_front(); - // append free into rlist_end - this->ready_cks.push_back(ck); + while (iter != this->free_cks.end() && length > 0) { + Chunk* ck = *iter; + iter++; + char* f_buf_start = &ck->data[ck->r_ofs]; + uint32_t ck_capacity = ck->block_size - ck->r_ofs; + if (ck_capacity >= length) { + // current data task is done + memcpy(f_buf_start, data, length); + ck->r_ofs += length; + length = 0; + } else if (ck_capacity > 0) //ck_capacity < length + { + memcpy(f_buf_start, data, ck_capacity); + length -= ck_capacity; + data = (const char*) data + ck_capacity; + ck->r_ofs += ck_capacity; } - return length; + this->ck_free_ck_capacity -= ck->block_size; + // remove free in flist + this->free_cks.pop_front(); + // append free into rlist_end + this->ready_cks.push_back(ck); + } + + return length; } uint32_t Chunks::ck_ceil_to_k(uint32_t i) { - if (i < threshold) - { - return threshold; - } + if (i < threshold) { return threshold; } - uint32_t k = 0x80000000; - while (k && !(k & i)) - { - k >>= 1; - } - return k << 1; + uint32_t k = 0x80000000; + while (k && !(k & i)) { k >>= 1; } + return k << 1; } int Chunks::copyDataIntoNewChunk(const void* data, uint32_t length) { - int mem_size = ck_ceil_to_k(sizeof(Chunk) + length); - - // new a chunk - Chunk* ck = (Chunk*) malloc(mem_size); - if (ck == NULL) - { - return -1; - } - ck->block_size = mem_size - sizeof(Chunk); - memcpy(&ck->data[0], data, length); - ck->r_ofs = length; - ck->l_ofs = 0; - /// insert into ready list - this->ready_cks.push_back(ck); - this->ck_alloc_size += mem_size; - return 0; + int mem_size = ck_ceil_to_k(sizeof(Chunk) + length); + + // new a chunk + Chunk* ck = (Chunk*) malloc(mem_size); + if (ck == NULL) { return -1; } + ck->block_size = mem_size - sizeof(Chunk); + memcpy(&ck->data[0], data, length); + ck->r_ofs = length; + ck->l_ofs = 0; + /// insert into ready list + this->ready_cks.push_back(ck); + this->ck_alloc_size += mem_size; + return 0; } void Chunks::reduceFreeCK() { - if (!this->free_cks.empty()) - { - Chunk* c = *this->free_cks.begin(); - this->free_cks.pop_front(); - this->ck_alloc_size -= (c->block_size + sizeof(Chunk) ); - this->ck_free_ck_capacity -= c->block_size; - free(c); - } + if (!this->free_cks.empty()) { + Chunk* c = *this->free_cks.begin(); + this->free_cks.pop_front(); + this->ck_alloc_size -= (c->block_size + sizeof(Chunk)); + this->ck_free_ck_capacity -= c->block_size; + free(c); + } } void Chunks::checkWaterLevel() { - while (this->c_resident_size < this->ck_alloc_size - && !this->free_cks.empty()) - { - this->reduceFreeCK(); - } + while (this->c_resident_size < this->ck_alloc_size && !this->free_cks.empty()) { this->reduceFreeCK(); } } -uint32_t Chunks::getAllocSize() const -{ - return this->ck_alloc_size; -} +uint32_t Chunks::getAllocSize() const { return this->ck_alloc_size; } -Chunks::Chunks(uint32_t max_size, uint32_t resident_size) : - c_resident_size(resident_size),c_max_size(max_size),threshold(1024) +Chunks::Chunks(uint32_t max_size, uint32_t resident_size) : c_resident_size(resident_size), c_max_size(max_size), threshold(1024) { - this->ck_alloc_size = 0; - this->ck_free_ck_capacity = 0; - if(max_size < resident_size) - throw std::invalid_argument("chunks: max_size must bigger then resident_size"); + this->ck_alloc_size = 0; + this->ck_free_ck_capacity = 0; + if (max_size < resident_size) throw std::invalid_argument("chunks: max_size must bigger then resident_size"); } Chunks::~Chunks() { - while (!this->ready_cks.empty()) - { - Chunk* c = this->ready_cks.front(); - free(c); - ready_cks.pop_front(); - } - - while (!this->free_cks.empty()) - { - Chunk* c = *this->free_cks.begin(); - free(c); - free_cks.pop_front(); - } - this->ck_free_ck_capacity = 0; + while (!this->ready_cks.empty()) { + Chunk* c = this->ready_cks.front(); + free(c); + ready_cks.pop_front(); + } + + while (!this->free_cks.empty()) { + Chunk* c = *this->free_cks.begin(); + free(c); + free_cks.pop_front(); + } + this->ck_free_ck_capacity = 0; } bool Chunks::useExistingChunk(uint32_t length) const { - Chunk * c = nullptr; - if(!this->ready_cks.empty()) - { - c = this->ready_cks.back(); - uint32_t availiable = c->block_size - c->r_ofs ; - if (availiable < length){ - return false; - }else{ - length -= availiable; - } + Chunk* c = nullptr; + if (!this->ready_cks.empty()) { + c = this->ready_cks.back(); + uint32_t availiable = c->block_size - c->r_ofs; + if (availiable < length) { + return false; + } else { + length -= availiable; } + } - if(this->ck_free_ck_capacity >=length) - { - return true; - } + if (this->ck_free_ck_capacity >= length) { return true; } - return false; + return false; } -int Chunks::copyDataIntoChunks(const void*data, uint32_t length) +int Chunks::copyDataIntoChunks(const void* data, uint32_t length) { - const char* p_in = (const char*) data; - int ret = 0; - - // fill order - // 1. ready ck - // 2. free ck - // 3. create a new ck - if ((ret = copyDataIntoReadyCK(p_in, length)) == 0) - { - goto DONE; - } + const char* p_in = (const char*) data; + int ret = 0; - p_in += (length - ret); - length = ret; + // fill order + // 1. ready ck + // 2. free ck + // 3. create a new ck + if ((ret = copyDataIntoReadyCK(p_in, length)) == 0) { goto DONE; } - if ((ret = copyDataIntoFreeCK(p_in, length)) == 0) - { - goto DONE; - } + p_in += (length - ret); + length = ret; - p_in += (length - ret); - length = ret; + if ((ret = copyDataIntoFreeCK(p_in, length)) == 0) { goto DONE; } - if ((ret = copyDataIntoNewChunk(p_in, length)) == -1) - { - // exhausting memory - return -1; - } + p_in += (length - ret); + length = ret; + + if ((ret = copyDataIntoNewChunk(p_in, length)) == -1) { + // exhausting memory + return -1; + } DONE: - return 0; + return 0; } int Chunks::drainOutWithPipe(std::function in_pipe_cb) { - if (this->ready_cks.empty()) - { - return 0; - } - this->iter = this->ready_cks.begin(); - - while (this->iter != this->ready_cks.end()) - { - Chunk* cur = *iter; - char* cur_buf = &cur->data[cur->l_ofs]; - uint32_t cur_size = cur->r_ofs - cur->l_ofs; - // call in_pipe_cb flush the data out - int ret = in_pipe_cb(cur_buf, cur_size); - if (ret <= 0) - { - return ret; - } - else if (ret == (int)cur_size) - { // current chunk is done, drop current chunk - // reset read offset - cur->l_ofs = 0; - //reset write offset - cur->r_ofs = 0; - // insert into free cks - this->ck_free_ck_capacity +=cur->block_size; - this->free_cks.push_front(cur); - // remove from read cks - iter++; - this->ready_cks.pop_front(); - } - else if (ret < (int)cur_size) - { // some are failed, resend at next time - cur->l_ofs += (uint32_t)ret; - } - } - this->checkWaterLevel(); - return 0; + if (this->ready_cks.empty()) { return 0; } + this->iter = this->ready_cks.begin(); + + while (this->iter != this->ready_cks.end()) { + Chunk* cur = *iter; + char* cur_buf = &cur->data[cur->l_ofs]; + uint32_t cur_size = cur->r_ofs - cur->l_ofs; + // call in_pipe_cb flush the data out + int ret = in_pipe_cb(cur_buf, cur_size); + if (ret <= 0) { + return ret; + } else if (ret == (int) cur_size) { // current chunk is done, drop current chunk + // reset read offset + cur->l_ofs = 0; + //reset write offset + cur->r_ofs = 0; + // insert into free cks + this->ck_free_ck_capacity += cur->block_size; + this->free_cks.push_front(cur); + // remove from read cks + iter++; + this->ready_cks.pop_front(); + } else if (ret < (int) cur_size) { // some are failed, resend at next time + cur->l_ofs += (uint32_t) ret; + } + } + this->checkWaterLevel(); + return 0; } void Chunks::resetChunks() { - while (!this->ready_cks.empty()) - { - Chunk* c = *this->ready_cks.begin(); - c->l_ofs = 0; - c->r_ofs = 0; - this->ready_cks.pop_front(); - this->ck_free_ck_capacity +=c->block_size; - this->free_cks.push_back(c); - } - this->checkWaterLevel(); + while (!this->ready_cks.empty()) { + Chunk* c = *this->ready_cks.begin(); + c->l_ofs = 0; + c->r_ofs = 0; + this->ready_cks.pop_front(); + this->ck_free_ck_capacity += c->block_size; + this->free_cks.push_back(c); + } + this->checkWaterLevel(); } -} \ No newline at end of file +} // namespace Cache \ No newline at end of file diff --git a/common/src/Cache/NodeTreeWriter.cpp b/common/src/Cache/NodeTreeWriter.cpp index 2402b4b71..edee091bb 100644 --- a/common/src/Cache/NodeTreeWriter.cpp +++ b/common/src/Cache/NodeTreeWriter.cpp @@ -1,12 +1,12 @@ //////////////////////////////////////////////////////////////////////////////// // Copyright 2020 NAVER Corp -// +// // 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 @@ -22,6 +22,6 @@ #include "NodeTreeWriter.h" -namespace Cache { - +namespace Cache +{ } /* namespace Cache */ diff --git a/common/src/Cache/SafeSharedState.cpp b/common/src/Cache/SafeSharedState.cpp index a410e0541..989c710d2 100644 --- a/common/src/Cache/SafeSharedState.cpp +++ b/common/src/Cache/SafeSharedState.cpp @@ -1,12 +1,12 @@ //////////////////////////////////////////////////////////////////////////////// // Copyright 2020 NAVER Corp -// +// // 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 @@ -22,55 +22,48 @@ #include "SafeSharedState.h" #include -namespace Cache { +namespace Cache +{ bool SafeSharedState::checkTraceLimit(int64_t timestamp) { - time_t ts = (timestamp != -1) ?(timestamp) :(std::time(NULL)); - - if(global_agent_info.trace_limit == -1) - { - return false; - } + time_t ts = (timestamp != -1) ? (timestamp) : (std::time(NULL)); + + if (global_agent_info.trace_limit == -1) { return false; } - if(global_agent_info.trace_limit == 0) - { - // block without any checking - goto BLOCK; - } + if (global_agent_info.trace_limit == 0) { + // block without any checking + goto BLOCK; + } - if( this->_global_state->timestamp != ts ) - { - this->_global_state->timestamp = ts; - this->_global_state->tick = 0 ; - __sync_synchronize(); - } - else if(this->_global_state->tick >= global_agent_info.trace_limit) - { - goto BLOCK; + if (this->_global_state->timestamp != ts) { + this->_global_state->timestamp = ts; + this->_global_state->tick = 0; + __sync_synchronize(); + } else if (this->_global_state->tick >= global_agent_info.trace_limit) { + goto BLOCK; // note: if offline, just test it in 5secs // }else if(this->isReady() == false){ // goto BLOCK; - }else - { - __sync_add_and_fetch(&this->_global_state->tick,1); - } - return false; + } else { + __sync_add_and_fetch(&this->_global_state->tick, 1); + } + return false; BLOCK: - pp_trace("This span dropped. max_trace_limit:%ld current_tick:%lld onLine:%d",global_agent_info.trace_limit, - this->_global_state->tick,this->isReady()?(1):(0)); - return true; + pp_trace("This span dropped. max_trace_limit:%ld current_tick:%lld onLine:%d", global_agent_info.trace_limit, this->_global_state->tick, + this->isReady() ? (1) : (0)); + return true; } SafeSharedState::SafeSharedState() { - // this->shmObj = ; - if(attach_shared_memory(&this->shmObj)){ - this->_global_state = (SharedState*)this->shmObj.region; - return ; - } - - throw std::runtime_error("can not attach shm memory"); + // this->shmObj = ; + if (attach_shared_memory(&this->shmObj)) { + this->_global_state = (SharedState*) this->shmObj.region; + return; + } + + throw std::runtime_error("can not attach shm memory"); } } /* namespace Cache */ diff --git a/common/src/ConnectionPool/SpanConnectionPool.cpp b/common/src/ConnectionPool/SpanConnectionPool.cpp index 5898fbaeb..6a91e37bd 100644 --- a/common/src/ConnectionPool/SpanConnectionPool.cpp +++ b/common/src/ConnectionPool/SpanConnectionPool.cpp @@ -26,82 +26,68 @@ namespace ConnectionPool { - using Cache::SafeSharedState; - namespace Json = AliasJson; - SpanConnectionPool::SpanConnectionPool(const char *co_host) : co_host(co_host), - con_counter(0) - { - this->_cPool.push(this->createTrans()); - } +using Cache::SafeSharedState; +namespace Json = AliasJson; +SpanConnectionPool::SpanConnectionPool(const char *co_host) : co_host(co_host), con_counter(0) { this->_cPool.push(this->createTrans()); } - TransConnection SpanConnectionPool::createTrans() - { - TransConnection _connect(new TransLayer(this->co_host)); - using namespace std::placeholders; - // _connect->registerPeerMsgCallback( - // std::bind(&SpanConnectionPool::_handleMsgFromCollector,this,_1,_2,_3), - // std::bind(&SpanConnectionPool::_handleTransLayerState,this,_1)); - - _connect->registerPeerMsgCallback( - std::bind(&SpanConnectionPool::_handleMsgFromCollector, this, _1, _2, _3), - nullptr); - this->con_counter++; +TransConnection SpanConnectionPool::createTrans() +{ + TransConnection _connect(new TransLayer(this->co_host)); + using namespace std::placeholders; + // _connect->registerPeerMsgCallback( + // std::bind(&SpanConnectionPool::_handleMsgFromCollector,this,_1,_2,_3), + // std::bind(&SpanConnectionPool::_handleTransLayerState,this,_1)); - return _connect; - } + _connect->registerPeerMsgCallback(std::bind(&SpanConnectionPool::_handleMsgFromCollector, this, _1, _2, _3), nullptr); + this->con_counter++; - //@obsoleted - // void SpanConnectionPool::_handleTransLayerState(int state) - // { - // if(state == E_OFFLINE) - // { - // if(global_agent_info.inter_flag & E_UTEST){ - // SafeSharedState::instance().markONLine(); - // } - // else{ - // SafeSharedState::instance().markOFFLine(); - // } - // } - // } + return _connect; +} - void SpanConnectionPool::_handleMsgFromCollector(int type, const char *buf, size_t len) - { - switch (type) - { +//@obsoleted +// void SpanConnectionPool::_handleTransLayerState(int state) +// { +// if(state == E_OFFLINE) +// { +// if(global_agent_info.inter_flag & E_UTEST){ +// SafeSharedState::instance().markONLine(); +// } +// else{ +// SafeSharedState::instance().markOFFLine(); +// } +// } +// } - case RESPONSE_AGENT_INFO: - this->_handle_agent_info(type, buf, len); - break; +void SpanConnectionPool::_handleMsgFromCollector(int type, const char *buf, size_t len) +{ + switch (type) { + case RESPONSE_AGENT_INFO: + this->_handle_agent_info(type, buf, len); + break; - default: - break; - } - } + default: + break; + } +} - void SpanConnectionPool::_handle_agent_info(int type, const char *buf, size_t len) - { - Json::Value root; - (void)type; - Json::CharReaderBuilder builder; - builder["collectComments"] = false; +void SpanConnectionPool::_handle_agent_info(int type, const char *buf, size_t len) +{ + Json::Value root; + (void) type; + Json::CharReaderBuilder builder; + builder["collectComments"] = false; - std::istringstream inss(std::string(buf, len)); - JSONCPP_STRING errs; - bool ok = parseFromStream(builder, inss, &root, &errs); + std::istringstream inss(std::string(buf, len)); + JSONCPP_STRING errs; + bool ok = parseFromStream(builder, inss, &root, &errs); - if (ok) - { - // pp_trace("collector-agent say:%s",root.toStyledString().c_str()); + if (ok) { + // pp_trace("collector-agent say:%s",root.toStyledString().c_str()); - if (root.isMember("time")) - { - SafeSharedState::instance().updateStartTime(atoll(root["time"].asCString())); - } - } - else - { - pp_trace("Recieve invalid msg: %.*s from Collector-agent, reason: %s", (int)len, buf, errs.c_str()); - } - } + if (root.isMember("time")) { SafeSharedState::instance().updateStartTime(atoll(root["time"].asCString())); } + } else { + pp_trace("Recieve invalid msg: %.*s from Collector-agent, reason: %s", (int) len, buf, errs.c_str()); + } +} } /* namespace ConnectionPool */ diff --git a/common/src/ConnectionPool/TransLayer.cpp b/common/src/ConnectionPool/TransLayer.cpp index 5a1b34d99..35c6bee5b 100644 --- a/common/src/ConnectionPool/TransLayer.cpp +++ b/common/src/ConnectionPool/TransLayer.cpp @@ -17,225 +17,181 @@ #include namespace ConnectionPool { - /** +/** * remote: localhost:port */ - int TransLayer::connect_stream_remote(const char *remote) - { - - int offset = strlen(remote) - 1; - - while (remote[offset] != ':') - { - offset--; - if (offset <= 0) - { - pp_trace("get an invalid remote %s", remote); - return -1; - } - } - - std::string hostname(remote, offset); - const char *port_str = remote + offset + 1; - // int port = atoi(remote+offset+1); - - struct addrinfo hints; - struct addrinfo *result, *rp; - memset(&hints, 0, sizeof(hints)); - hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */ - hints.ai_socktype = SOCK_STREAM; /* Datagram socket */ - hints.ai_flags = 0; - hints.ai_protocol = 0; /* Any protocol */ - - int s = 0; - s = getaddrinfo(hostname.c_str(), port_str, &hints, &result); - if (s != 0) - { - pp_trace("getaddrinfo failed: hostname:%s msg:%s ", hostname.c_str(), gai_strerror(s)); - return -1; - } - int sfd = -1; - for (rp = result; rp != NULL; rp = rp->ai_next) - { - sfd = socket(rp->ai_family, rp->ai_socktype, - rp->ai_protocol); - - struct linger fd_linger = {1, 1}; // open and 1 second - // mark it as nonblock - fcntl(sfd, F_SETFL, fcntl(sfd, F_GETFL, 0) | O_NONBLOCK); - setsockopt(sfd, SOL_SOCKET, SO_LINGER, &fd_linger, sizeof(fd_linger)); - - if (sfd == -1) - continue; - int ret = connect(sfd, rp->ai_addr, rp->ai_addrlen); - if (ret == 0) - { - break; - } - else if (ret == -1) - { - if (errno == EALREADY || errno == EINPROGRESS) - break; - } - - close(sfd); - sfd = -1; - } - freeaddrinfo(result); - - return sfd; +int TransLayer::connect_stream_remote(const char *remote) +{ + int offset = strlen(remote) - 1; + + while (remote[offset] != ':') { + offset--; + if (offset <= 0) { + pp_trace("get an invalid remote %s", remote); + return -1; } + } + + std::string hostname(remote, offset); + const char *port_str = remote + offset + 1; + // int port = atoi(remote+offset+1); + + struct addrinfo hints; + struct addrinfo *result, *rp; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; /* Allow IPv4 or IPv6 */ + hints.ai_socktype = SOCK_STREAM; /* Datagram socket */ + hints.ai_flags = 0; + hints.ai_protocol = 0; /* Any protocol */ + + int s = 0; + s = getaddrinfo(hostname.c_str(), port_str, &hints, &result); + if (s != 0) { + pp_trace("getaddrinfo failed: hostname:%s msg:%s ", hostname.c_str(), gai_strerror(s)); + return -1; + } + int sfd = -1; + for (rp = result; rp != NULL; rp = rp->ai_next) { + sfd = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol); + + struct linger fd_linger = {1, 1}; // open and 1 second + // mark it as nonblock + fcntl(sfd, F_SETFL, fcntl(sfd, F_GETFL, 0) | O_NONBLOCK); + setsockopt(sfd, SOL_SOCKET, SO_LINGER, &fd_linger, sizeof(fd_linger)); + + if (sfd == -1) continue; + int ret = connect(sfd, rp->ai_addr, rp->ai_addrlen); + if (ret == 0) { + break; + } else if (ret == -1) { + if (errno == EALREADY || errno == EINPROGRESS) break; + } + + close(sfd); + sfd = -1; + } + freeaddrinfo(result); - int TransLayer::connect_unix_remote(const char *remote) - { - int fd = -1; + return sfd; +} + +int TransLayer::connect_unix_remote(const char *remote) +{ + int fd = -1; #if defined(__APPLE__) - struct sockaddr_un u_sock = {0, 0, {0}}; + struct sockaddr_un u_sock = {0, 0, {0}}; #else - struct sockaddr_un u_sock = {0, {0}}; + struct sockaddr_un u_sock = {0, {0}}; #endif - struct linger fd_linger = {1, 1}; // open and 1 second - if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) - { - pp_trace(" get socket error,(%s)", strerror(errno)); - goto ERROR; - } - - u_sock.sun_family = AF_UNIX; - strncpy(u_sock.sun_path, remote, sizeof(u_sock.sun_path) - 1); - - // mark fd as non blocking - fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK); - - setsockopt(fd, SOL_SOCKET, SO_LINGER, &fd_linger, sizeof(fd_linger)); - - if (connect(fd, (struct sockaddr *)&u_sock, sizeof(u_sock)) != 0) - { - if (errno != EALREADY || errno != EINPROGRESS) - { - pp_trace("connect:(%s) failed as (%s)", remote, strerror(errno)); - goto ERROR; - } - } - pp_trace("connected to %s", remote); - - return fd; - - ERROR: - if (fd > 0) - { - close(fd); - } - - return -1; + struct linger fd_linger = {1, 1}; // open and 1 second + if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) { + pp_trace(" get socket error,(%s)", strerror(errno)); + goto ERROR; + } + + u_sock.sun_family = AF_UNIX; + strncpy(u_sock.sun_path, remote, sizeof(u_sock.sun_path) - 1); + + // mark fd as non blocking + fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK); + + setsockopt(fd, SOL_SOCKET, SO_LINGER, &fd_linger, sizeof(fd_linger)); + + if (connect(fd, (struct sockaddr *) &u_sock, sizeof(u_sock)) != 0) { + if (errno != EALREADY || errno != EINPROGRESS) { + pp_trace("connect:(%s) failed as (%s)", remote, strerror(errno)); + goto ERROR; } + } + pp_trace("connected to %s", remote); + + return fd; + +ERROR: + if (fd > 0) { close(fd); } + + return -1; +} + +size_t TransLayer::trans_layer_pool(uint32_t timeout) +{ + if (c_fd == -1) { + pp_trace("agent try to connect:(%s)", this->co_host.c_str()); + connect_remote(this->co_host.c_str()); - size_t TransLayer::trans_layer_pool(uint32_t timeout) - { - if (c_fd == -1) - { - pp_trace("agent try to connect:(%s)", this->co_host.c_str()); - connect_remote(this->co_host.c_str()); - - if (c_fd == -1) - { - return -1; - } - } - - int fd = c_fd; - fd_set wfds, efds, rfds; - FD_ZERO(&efds); - - FD_ZERO(&wfds); - FD_ZERO(&rfds); - - if (this->_state & S_ERROR) - { - FD_SET(fd, &efds); - } - - if (this->_state & S_WRITING) - { - FD_SET(fd, &wfds); - } - - if (this->_state & S_READING) - { - FD_SET(fd, &rfds); - } - - struct timeval tv = {0, (int)timeout * 1000}; - - int retval = select(fd + 1, &rfds, &wfds, &efds, &tv); - if (retval == -1) - { - // it helped address the macosx issue - pp_trace("select return error:(%s)", strerror(errno)); - return -1; - } - else if (retval > 0) - { - - if ((this->_state & S_ERROR) && FD_ISSET(fd, &efds)) - { - pp_trace("select fd:(%s) ", strerror(errno)); - goto ERROR; - } - - if ((this->_state & S_WRITING) && FD_ISSET(fd, &wfds)) - { - if (_send_msg_to_collector() == -1) - { - goto ERROR; - } - } - - if ((this->_state & S_READING) && FD_ISSET(fd, &rfds)) - { - if (_recv_msg_from_collector() == -1) - { - pp_trace("recv_msg_from_collector error"); - goto ERROR; - } - } - } - else - { - // timeout do nothing - // total =0 ,timeout - } - - return 0; - - ERROR: - - _reset_remote(); - - connect_remote(this->co_host.c_str()); - return -1; + if (c_fd == -1) { return -1; } + } + + int fd = c_fd; + fd_set wfds, efds, rfds; + FD_ZERO(&efds); + + FD_ZERO(&wfds); + FD_ZERO(&rfds); + + if (this->_state & S_ERROR) { FD_SET(fd, &efds); } + + if (this->_state & S_WRITING) { FD_SET(fd, &wfds); } + + if (this->_state & S_READING) { FD_SET(fd, &rfds); } + + struct timeval tv = {0, (int) timeout * 1000}; + + int retval = select(fd + 1, &rfds, &wfds, &efds, &tv); + if (retval == -1) { + // it helped address the macosx issue + pp_trace("select return error:(%s)", strerror(errno)); + return -1; + } else if (retval > 0) { + if ((this->_state & S_ERROR) && FD_ISSET(fd, &efds)) { + pp_trace("select fd:(%s) ", strerror(errno)); + goto ERROR; } - bool TransLayer::copy_into_send_buffer(const std::string &data) - { - Header header; - header.length = htonl(data.size()); - header.type = htonl(REQ_UPDATE_SPAN); - - if (this->chunks.checkCapacity(sizeof(header) + data.size()) == false) - { - pp_trace("Send buffer is full. size:[%ld]", data.size() + sizeof(header)); - return false; - } - // copy header - this->chunks.copyDataIntoChunks((const char *)&header, sizeof(header)); - // copy body - this->chunks.copyDataIntoChunks(data.data(), data.size()); - // enable write event - this->_state |= S_WRITING; - return true; + if ((this->_state & S_WRITING) && FD_ISSET(fd, &wfds)) { + if (_send_msg_to_collector() == -1) { goto ERROR; } } - const char *TransLayer::UNIX_SOCKET = "unix:"; - const char *TransLayer::TCP_SOCKET = "tcp:"; -} \ No newline at end of file + if ((this->_state & S_READING) && FD_ISSET(fd, &rfds)) { + if (_recv_msg_from_collector() == -1) { + pp_trace("recv_msg_from_collector error"); + goto ERROR; + } + } + } else { + // timeout do nothing + // total =0 ,timeout + } + + return 0; + +ERROR: + + _reset_remote(); + + connect_remote(this->co_host.c_str()); + return -1; +} + +bool TransLayer::copy_into_send_buffer(const std::string &data) +{ + Header header; + header.length = htonl(data.size()); + header.type = htonl(REQ_UPDATE_SPAN); + + if (this->chunks.checkCapacity(sizeof(header) + data.size()) == false) { + pp_trace("Send buffer is full. size:[%ld]", data.size() + sizeof(header)); + return false; + } + // copy header + this->chunks.copyDataIntoChunks((const char *) &header, sizeof(header)); + // copy body + this->chunks.copyDataIntoChunks(data.data(), data.size()); + // enable write event + this->_state |= S_WRITING; + return true; +} + +const char *TransLayer::UNIX_SOCKET = "unix:"; +const char *TransLayer::TCP_SOCKET = "tcp:"; +} // namespace ConnectionPool \ No newline at end of file diff --git a/common/src/Context/ContextType.cpp b/common/src/Context/ContextType.cpp index 5518ba107..3d2a27595 100644 --- a/common/src/Context/ContextType.cpp +++ b/common/src/Context/ContextType.cpp @@ -1,12 +1,12 @@ //////////////////////////////////////////////////////////////////////////////// // Copyright 2020 NAVER Corp -// +// // 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 @@ -22,6 +22,6 @@ #include "ContextType.h" -namespace Context { - +namespace Context +{ } /* namespace Context */ diff --git a/common/src/NodePool/PoolManager.cpp b/common/src/NodePool/PoolManager.cpp index 7c251bfee..b7b06bc45 100644 --- a/common/src/NodePool/PoolManager.cpp +++ b/common/src/NodePool/PoolManager.cpp @@ -32,146 +32,114 @@ namespace NodePool { +void freeNodeTree(NodeID nodeId) +{ + if (nodeId == E_INVALID_NODE || nodeId == E_ROOT_NODE) { return; } + + NodeID child_id, next_id; + + if (PoolManager::getInstance().Restore(nodeId, child_id, next_id)) { + if (next_id != E_INVALID_NODE) { freeNodeTree(next_id); } + + if (child_id != E_INVALID_NODE) { freeNodeTree(child_id); } + } + + // while (child_id != E_INVALID_NODE) + // { + // WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(child_id); + // next_id = r_node->mNextId; + // freeNodeTree(child_id); + // child_id = next_id; + // } + + // PoolManager::getInstance().Restore(rootId); +} +bool PoolManager::Restore(NodeID id, NodeID &child_id, NodeID &next_id) +{ + for (int i = 0; i < 1000; i++) { + if (this->_restore(id, child_id, next_id, false)) { return true; } + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + pp_trace("[🐛]Restore node failed: #%d; node restore forcefully", id); + return this->_restore(id, child_id, next_id, true); +} + +// avoiding `locking and waitting` +bool PoolManager::_restore(NodeID id, NodeID &child_id, NodeID &next_id, bool force) +{ + std::lock_guard _safe(this->_lock); + + int32_t index = (int32_t) id - 1; + + if (this->indexInAliveVec(index) == false) { + pp_trace("%d not alive !!!", id); + child_id = E_INVALID_NODE; + next_id = E_INVALID_NODE; + return true; + } + + // check refcount + TraceNode &node = this->_fetchNodeBy(id); + + if (node.checkZoreRef() == false && force == false) { + // DO NOT TOUCH out id + return false; + } else { + this->_aliveNodeSet[index] = false; + child_id = node.mChildHeadId; + next_id = node.mNextId; + this->_freeNodeList.push(index); + return true; + } +} - void freeNodeTree(NodeID nodeId) - { - if (nodeId == E_INVALID_NODE || nodeId == E_ROOT_NODE) - { - return; - } - - NodeID child_id, next_id; - - if (PoolManager::getInstance().Restore(nodeId, child_id, next_id)) - { - if (next_id != E_INVALID_NODE) - { - freeNodeTree(next_id); - } - - if (child_id != E_INVALID_NODE) - { - freeNodeTree(child_id); - } - } - - // while (child_id != E_INVALID_NODE) - // { - // WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(child_id); - // next_id = r_node->mNextId; - // freeNodeTree(child_id); - // child_id = next_id; - // } - - // PoolManager::getInstance().Restore(rootId); - } - bool PoolManager::Restore(NodeID id, NodeID &child_id, NodeID &next_id) - { - for (int i = 0; i < 1000; i++) - { - if (this->_restore(id, child_id, next_id, false)) - { - return true; - } - std::this_thread::sleep_for(std::chrono::milliseconds(1)); - } - pp_trace("[🐛]Restore node failed: #%d; node restore forcefully", id); - return this->_restore(id, child_id, next_id, true); - } - - // avoiding `locking and waitting` - bool PoolManager::_restore(NodeID id, NodeID &child_id, NodeID &next_id, bool force) - { - std::lock_guard _safe(this->_lock); - - int32_t index = (int32_t)id - 1; - - if (this->indexInAliveVec(index) == false) - { - pp_trace("%d not alive !!!", id); - child_id = E_INVALID_NODE; - next_id = E_INVALID_NODE; - return true; - } - - // check refcount - TraceNode &node = this->_fetchNodeBy(id); - - if (node.checkZoreRef() == false && force == false) - { - // DO NOT TOUCH out id - return false; - } - else - { - this->_aliveNodeSet[index] = false; - child_id = node.mChildHeadId; - next_id = node.mNextId; - this->_freeNodeList.push(index); - return true; - } - } - - TraceNode &PoolManager::_fetchNodeBy(NodeID id) - { - // assert(id != E_INVALID_NODE); - if (id == E_ROOT_NODE) - { - throw std::out_of_range("id should not be 0"); - } - - int32_t index = int32_t(id) - 1; - - if (this->indexInAliveVec(index) == false) - { - std::string msg = "#"; - msg += std::to_string(id) + " is not alive"; - throw std::out_of_range(msg); - } - - return this->nodeIndexVec[index / CELL_SIZE][index % CELL_SIZE]; - } - - TraceNode &PoolManager::_getInitNode() noexcept - { // create a new node - if (this->_freeNodeList.empty()) - { - this->expandOnce(); - } - // as it holds a _lock, so no more _freeNodeList is empty - int32_t index = this->_freeNodeList.top(); - this->_freeNodeList.pop(); - this->_aliveNodeSet[index] = true; - return this->nodeIndexVec[index / CELL_SIZE][index % CELL_SIZE].reset(NodeID(index + 1)); - } - - TraceNode &PoolManager::_take(NodeID id) - { - if (id != E_ROOT_NODE) - { - return this->_fetchNodeBy(id); - } - else - { - return this->_getInitNode(); - } - } - - void PoolManager::expandOnce() - { - ADDTRACE(); - // pp_trace("Node pool expanding self! Old size:%ld", this->nodeIndexVec.size() * CELL_SIZE); - // append new nodes into nodeIndexVec - this->nodeIndexVec.push_back(std::unique_ptr(new TraceNode[CELL_SIZE])); - // this->nodeIndexVec.push_back(std::make_unique(CELL_SIZE)); - // append new bitflag into aliveNodeSet - this->_aliveNodeSet.insert(this->_aliveNodeSet.end(), this->_emptyAliveSet.begin(), this->_emptyAliveSet.end()); - for (int32_t id = this->maxId; id < (this->maxId + CELL_SIZE); id++) - { - this->_freeNodeList.push(id); - } - this->maxId += CELL_SIZE; - // pp_trace("Node pool expanding is done! news size:%ld", this->nodeIndexVec.size() * CELL_SIZE); - assert(this->nodeIndexVec.size() * CELL_SIZE == this->_aliveNodeSet.size()); - } +TraceNode &PoolManager::_fetchNodeBy(NodeID id) +{ + // assert(id != E_INVALID_NODE); + if (id == E_ROOT_NODE) { throw std::out_of_range("id should not be 0"); } + + int32_t index = int32_t(id) - 1; + + if (this->indexInAliveVec(index) == false) { + std::string msg = "#"; + msg += std::to_string(id) + " is not alive"; + throw std::out_of_range(msg); + } + + return this->nodeIndexVec[index / CELL_SIZE][index % CELL_SIZE]; +} + +TraceNode &PoolManager::_getInitNode() noexcept +{ // create a new node + if (this->_freeNodeList.empty()) { this->expandOnce(); } + // as it holds a _lock, so no more _freeNodeList is empty + int32_t index = this->_freeNodeList.top(); + this->_freeNodeList.pop(); + this->_aliveNodeSet[index] = true; + return this->nodeIndexVec[index / CELL_SIZE][index % CELL_SIZE].reset(NodeID(index + 1)); +} + +TraceNode &PoolManager::_take(NodeID id) +{ + if (id != E_ROOT_NODE) { + return this->_fetchNodeBy(id); + } else { + return this->_getInitNode(); + } +} + +void PoolManager::expandOnce() +{ + ADDTRACE(); + // pp_trace("Node pool expanding self! Old size:%ld", this->nodeIndexVec.size() * CELL_SIZE); + // append new nodes into nodeIndexVec + this->nodeIndexVec.push_back(std::unique_ptr(new TraceNode[CELL_SIZE])); + // this->nodeIndexVec.push_back(std::make_unique(CELL_SIZE)); + // append new bitflag into aliveNodeSet + this->_aliveNodeSet.insert(this->_aliveNodeSet.end(), this->_emptyAliveSet.begin(), this->_emptyAliveSet.end()); + for (int32_t id = this->maxId; id < (this->maxId + CELL_SIZE); id++) { this->_freeNodeList.push(id); } + this->maxId += CELL_SIZE; + // pp_trace("Node pool expanding is done! news size:%ld", this->nodeIndexVec.size() * CELL_SIZE); + assert(this->nodeIndexVec.size() * CELL_SIZE == this->_aliveNodeSet.size()); } +} // namespace NodePool diff --git a/common/src/NodePool/PoolManager.h b/common/src/NodePool/PoolManager.h index cac2f8d0f..57c4efe48 100644 --- a/common/src/NodePool/PoolManager.h +++ b/common/src/NodePool/PoolManager.h @@ -31,38 +31,37 @@ namespace NodePool { +class PoolManager +{ + private: + TraceNode &_fetchNodeBy(NodeID id); - class PoolManager - { - private: - TraceNode &_fetchNodeBy(NodeID id); - - TraceNode &_getInitNode(void) noexcept; + TraceNode &_getInitNode(void) noexcept; - TraceNode &_take(NodeID id); + TraceNode &_take(NodeID id); - bool _restore(NodeID id, NodeID &child_id, NodeID &next_id, bool force); + bool _restore(NodeID id, NodeID &child_id, NodeID &next_id, bool force); - public: - /** + public: + /** * @brief take is not safe, you should avoid use under MT * note: try PoolManager::getInstance().GetWrapperNode * @param id * @return TraceNode& */ - inline TraceNode &Take(NodeID id = E_ROOT_NODE) - { - std::lock_guard _safe(this->_lock); - return this->_take(id); - } - - inline WrapperTraceNode GetWrapperNode(NodeID id = E_ROOT_NODE) - { - std::lock_guard _safe(this->_lock); - TraceNode &e = this->_take(id); - return WrapperTraceNode(&e); - } - /** + inline TraceNode &Take(NodeID id = E_ROOT_NODE) + { + std::lock_guard _safe(this->_lock); + return this->_take(id); + } + + inline WrapperTraceNode GetWrapperNode(NodeID id = E_ROOT_NODE) + { + std::lock_guard _safe(this->_lock); + TraceNode &e = this->_take(id); + return WrapperTraceNode(&e); + } + /** * @brief restore id->traceNode to pool * * @param id @@ -71,91 +70,79 @@ namespace NodePool * @return true * @return false */ - bool Restore(NodeID id, NodeID &child_id, NodeID &next_id); - - inline bool Restore(TraceNode &node) - { - NodeID node1, node2; - return this->Restore(node.getId(), node1, node2); - } - - uint32_t totoalNodesCount() - { - std::lock_guard _safe(this->_lock); - return nodeIndexVec.size() * CELL_SIZE; - } - - uint32_t freeNodesCount() - { - std::lock_guard _safe(this->_lock); - return this->_freeNodeList.size(); - } - - void foreachAliveNode(std::function func) - { - std::lock_guard _safe(this->_lock); - for (int32_t index = 0; index < this->maxId; index++) - { - if (this->indexInAliveVec(index)) - { - func(this->_fetchNodeBy((NodeID)(index + 1))); - } - } - } + bool Restore(NodeID id, NodeID &child_id, NodeID &next_id); + + inline bool Restore(TraceNode &node) + { + NodeID node1, node2; + return this->Restore(node.getId(), node1, node2); + } + + uint32_t totoalNodesCount() + { + std::lock_guard _safe(this->_lock); + return nodeIndexVec.size() * CELL_SIZE; + } + + uint32_t freeNodesCount() + { + std::lock_guard _safe(this->_lock); + return this->_freeNodeList.size(); + } + + void foreachAliveNode(std::function func) + { + std::lock_guard _safe(this->_lock); + for (int32_t index = 0; index < this->maxId; index++) { + if (this->indexInAliveVec(index)) { func(this->_fetchNodeBy((NodeID)(index + 1))); } + } + } #ifdef COMMON_DEBUG - inline bool NoNodeLeak() - { - std::lock_guard _safe(this->_lock); - return this->_freeNodeList.size() == nodeIndexVec.size() * CELL_SIZE; - } + inline bool NoNodeLeak() + { + std::lock_guard _safe(this->_lock); + return this->_freeNodeList.size() == nodeIndexVec.size() * CELL_SIZE; + } #endif - virtual ~PoolManager() - { - } - - public: - static PoolManager &getInstance() - { - static PoolManager _instance; - return _instance; - } + virtual ~PoolManager() {} + + public: + static PoolManager &getInstance() + { + static PoolManager _instance; + return _instance; + } #ifndef COMMON_DEBUG - private: + private: #endif - PoolManager() : maxId(E_ROOT_NODE) - { - this->_emptyAliveSet.reserve(CELL_SIZE); - for (int i = 0; i < CELL_SIZE; i++) - { - this->_emptyAliveSet.push_back(false); - } - this->expandOnce(); - } - - private: - inline bool indexInAliveVec(int32_t index) - { - if (index >= 0 && index < this->maxId) - { - return this->_aliveNodeSet.at(index); - } - return false; - } - - void expandOnce(); - - private: - std::mutex _lock; - // std::set _aliveNodeSet; - std::vector _aliveNodeSet; - std::vector _emptyAliveSet; - int32_t maxId; - std::stack _freeNodeList; - static const int CELL_SIZE = 128; - std::vector> nodeIndexVec; - }; - void freeNodeTree(NodeID root); -} + PoolManager() : maxId(E_ROOT_NODE) + { + this->_emptyAliveSet.reserve(CELL_SIZE); + for (int i = 0; i < CELL_SIZE; i++) { this->_emptyAliveSet.push_back(false); } + this->expandOnce(); + } + + private: + inline bool indexInAliveVec(int32_t index) + { + if (index >= 0 && index < this->maxId) { return this->_aliveNodeSet.at(index); } + return false; + } + + void expandOnce(); + + private: + std::mutex _lock; + // std::set _aliveNodeSet; + std::vector _aliveNodeSet; + std::vector _emptyAliveSet; + int32_t maxId; + std::stack _freeNodeList; + static const int CELL_SIZE = 128; + std::vector> nodeIndexVec; +}; +void freeNodeTree(NodeID root); +} // namespace NodePool #endif /* COMMON_SRC_NODEPOOL_POOLMANAGER_H_ */ diff --git a/common/src/NodePool/TraceNode.cpp b/common/src/NodePool/TraceNode.cpp index 43e362b62..da557627e 100644 --- a/common/src/NodePool/TraceNode.cpp +++ b/common/src/NodePool/TraceNode.cpp @@ -27,154 +27,123 @@ namespace NodePool { - // static std::atomic _uid_; - WrapperTraceNode::WrapperTraceNode(TraceNode *node) : _traceNode(node) - { - assert(_traceNode != nullptr); - _traceNode->addRef(); - } +// static std::atomic _uid_; +WrapperTraceNode::WrapperTraceNode(TraceNode *node) : _traceNode(node) +{ + assert(_traceNode != nullptr); + _traceNode->addRef(); +} - WrapperTraceNode::~WrapperTraceNode() - { - if (_traceNode != nullptr) - { - _traceNode->rmRef(); - } - } - TraceNode::~TraceNode() - { - } +WrapperTraceNode::~WrapperTraceNode() +{ + if (_traceNode != nullptr) { _traceNode->rmRef(); } +} +TraceNode::~TraceNode() {} - void TraceNode::clearAttach() - { - // empty the json value - if (!this->_value.empty()) - this->_value.clear(); // Json::Value(); +void TraceNode::clearAttach() +{ + // empty the json value + if (!this->_value.empty()) this->_value.clear(); // Json::Value(); - if (!this->_context.empty()) - this->_context.clear(); + if (!this->_context.empty()) this->_context.clear(); - if (!this->_endTraceCallback.empty()) - this->_endTraceCallback.clear(); - } + if (!this->_endTraceCallback.empty()) this->_endTraceCallback.clear(); +} - void TraceNode::initId(NodeID &id) - { - this->mPoolIndex = id; - } +void TraceNode::initId(NodeID &id) { this->mPoolIndex = id; } - void TraceNode::addChild(WrapperTraceNode &child) - { - std::lock_guard _safe(this->mlock); +void TraceNode::addChild(WrapperTraceNode &child) +{ + std::lock_guard _safe(this->mlock); - if (this->mChildHeadId != E_INVALID_NODE) - child->mNextId = this->mChildHeadId; + if (this->mChildHeadId != E_INVALID_NODE) child->mNextId = this->mChildHeadId; - this->mChildHeadId = child->mPoolIndex; + this->mChildHeadId = child->mPoolIndex; - child->mParentId = this->mPoolIndex; - child->mRootIndex = this->mRootIndex; - child->root_start_time = this->root_start_time; - } + child->mParentId = this->mPoolIndex; + child->mRootIndex = this->mRootIndex; + child->root_start_time = this->root_start_time; +} - void TraceNode::endTimer() - { +void TraceNode::endTimer() +{ + uint64_t end_time = Helper::get_current_msec_stamp(); - uint64_t end_time = Helper::get_current_msec_stamp(); + this->cumulative_time += (end_time - this->start_time); +} - this->cumulative_time += (end_time - this->start_time); - } +void TraceNode::wakeUp() { this->start_time = Helper::get_current_msec_stamp(); } - void TraceNode::wakeUp() - { - this->start_time = Helper::get_current_msec_stamp(); - } +void TraceNode::convertToSpan() +{ + this->AddTraceDetail("E", this->cumulative_time); + this->AddTraceDetail("S", this->start_time); - void TraceNode::convertToSpan() - { - this->AddTraceDetail("E", this->cumulative_time); - this->AddTraceDetail("S", this->start_time); + this->AddTraceDetail("FT", global_agent_info.agent_type); +} - this->AddTraceDetail("FT", global_agent_info.agent_type); - } +void TraceNode::convertToSpanEvent() +{ + this->AddTraceDetail("E", this->cumulative_time); + this->AddTraceDetail("S", this->start_time - this->root_start_time); +} - void TraceNode::convertToSpanEvent() - { - this->AddTraceDetail("E", this->cumulative_time); - this->AddTraceDetail("S", this->start_time - this->root_start_time); - } +// void TraceNode::setTraceParent(WrapperTraceNode &parent, WrapperTraceNode &root) +// { +// std::lock_guard _safe(this->mlock); +// this->mRootIndex = root->mPoolIndex; +// this->mParentId = parent->mPoolIndex; +// this->root_start_time = root->root_start_time; +// } - // void TraceNode::setTraceParent(WrapperTraceNode &parent, WrapperTraceNode &root) - // { - // std::lock_guard _safe(this->mlock); - // this->mRootIndex = root->mPoolIndex; - // this->mParentId = parent->mPoolIndex; - // this->root_start_time = root->root_start_time; - // } - - void TraceNode::startTimer() - { - uint64_t time_in_ms = Helper::get_current_msec_stamp(); - this->start_time = time_in_ms; - this->root_start_time = time_in_ms; - } +void TraceNode::startTimer() +{ + uint64_t time_in_ms = Helper::get_current_msec_stamp(); + this->start_time = time_in_ms; + this->root_start_time = time_in_ms; +} - void TraceNode::parseOpt(std::string key, std::string value) - { - pp_trace("#%d add opt: key:%s value:%s", mPoolIndex, key.c_str(), value.c_str()); - if (key == "TraceMinTimeMs") - { - int64_t min = std::stoll(value); - auto cb = [=]() -> bool - { - pp_trace("checkOpt: #%d TraceMinTimeMs:%ld cumulative_time:%lu", this->mPoolIndex, min, this->cumulative_time); - if ((int64_t)this->cumulative_time >= min) - return true; - return false; - }; - this->_endTraceCallback.push_back(cb); - } - else if (key == "TraceOnlyException") - { - auto cb = [=]() -> bool - { - return this->mHasExp; - }; - - this->_endTraceCallback.push_back(cb); - } - } +void TraceNode::parseOpt(std::string key, std::string value) +{ + pp_trace("#%d add opt: key:%s value:%s", mPoolIndex, key.c_str(), value.c_str()); + if (key == "TraceMinTimeMs") { + int64_t min = std::stoll(value); + auto cb = [=]() -> bool { + pp_trace("checkOpt: #%d TraceMinTimeMs:%ld cumulative_time:%lu", this->mPoolIndex, min, this->cumulative_time); + if ((int64_t) this->cumulative_time >= min) return true; + return false; + }; + this->_endTraceCallback.push_back(cb); + } else if (key == "TraceOnlyException") { + auto cb = [=]() -> bool { return this->mHasExp; }; + + this->_endTraceCallback.push_back(cb); + } +} - bool TraceNode::checkOpt() - { - bool ret = true; - for (auto &cb : this->_endTraceCallback) - { - if ((ret = cb()) == true) - return ret; - } - return ret; - } +bool TraceNode::checkOpt() +{ + bool ret = true; + for (auto &cb : this->_endTraceCallback) { + if ((ret = cb()) == true) return ret; + } + return ret; +} - void TraceNode::setOpt(const char *opt, va_list *args) - { - const char *var = opt; - - while (var != nullptr) - { - - const char *delimit = strchr(var, ':'); - if (delimit == nullptr) - { - this->parseOpt(std::string(var), ""); - } - else - { - std::string key(var, delimit - var); - std::string value(delimit + 1); - this->parseOpt(key, value); - } - var = va_arg(*args, const char *); - } +void TraceNode::setOpt(const char *opt, va_list *args) +{ + const char *var = opt; + + while (var != nullptr) { + const char *delimit = strchr(var, ':'); + if (delimit == nullptr) { + this->parseOpt(std::string(var), ""); + } else { + std::string key(var, delimit - var); + std::string value(delimit + 1); + this->parseOpt(key, value); } + var = va_arg(*args, const char *); + } } +} // namespace NodePool diff --git a/common/src/NodePool/TraceNode.h b/common/src/NodePool/TraceNode.h index f504757eb..fac8c636d 100644 --- a/common/src/NodePool/TraceNode.h +++ b/common/src/NodePool/TraceNode.h @@ -34,278 +34,249 @@ namespace NodePool { +namespace Json = AliasJson; +using Context::ContextType; +using Context::LongContextType; +using Context::StringContextType; +class TraceNode; +const static int MAX_SUB_TRACE_NODES_LIMIT = 2048; +class WrapperTraceNode +{ + public: + WrapperTraceNode() = delete; + WrapperTraceNode(const WrapperTraceNode &other) = delete; + WrapperTraceNode(WrapperTraceNode &&other) : _traceNode(std::move(other._traceNode)) { other._traceNode = nullptr; } + + WrapperTraceNode &operator=(const WrapperTraceNode &other) = delete; + + WrapperTraceNode(TraceNode *node); + TraceNode *operator->() { return _traceNode; } + ~WrapperTraceNode(); - namespace Json = AliasJson; - using Context::ContextType; - using Context::LongContextType; - using Context::StringContextType; - class TraceNode; - const static int MAX_SUB_TRACE_NODES_LIMIT = 2048; - class WrapperTraceNode - { - public: - WrapperTraceNode() = delete; - WrapperTraceNode(const WrapperTraceNode &other) = delete; - WrapperTraceNode(WrapperTraceNode &&other) : _traceNode(std::move(other._traceNode)) - { - other._traceNode = nullptr; - } - - WrapperTraceNode &operator=(const WrapperTraceNode &other) = delete; - - WrapperTraceNode(TraceNode *node); - TraceNode *operator->() - { - return _traceNode; - } - ~WrapperTraceNode(); - - private: - TraceNode *_traceNode; - }; - - typedef std::shared_ptr _ContextType_; - class TraceNode - { - public: - NodeID mNextId; // equal brother node - NodeID mChildHeadId; // subtree/child tree - - NodeID mParentId; // parent Id [end_trace] avoiding re-add - NodeID mRootIndex; // highway to root node - NodeID mPoolIndex; - // int64_t mUID; - // int64_t mParentUID; - // int64_t mRootUID; - - uint64_t start_time; - uint64_t fetal_error_time; - uint64_t limit; - uint64_t cumulative_time; - uint64_t root_start_time; - bool mHasExp; - - public: - void startTimer(); - void endTimer(); - void wakeUp(); - - void convertToSpanEvent(); - void convertToSpan(); - - public: - void addChild(WrapperTraceNode &child); - void remove(); - - inline bool isRoot() const - { - return this->mRootIndex == mPoolIndex; - } - - inline bool isLeaf() const - { - return this->mChildHeadId == E_INVALID_NODE; - } - - public: - TraceNode() - { - this->mPoolIndex = E_INVALID_NODE; - this->mRootIndex = E_INVALID_NODE; - this->resetRelative(); - this->resetStatus(); - this->_mRef = 0; - } - - virtual ~TraceNode(); - - TraceNode &reset(NodeID id) - { - std::lock_guard _safe(this->mlock); - this->clearAttach(); - this->initId(id); - this->resetStatus(); - this->resetRelative(); - this->_mRef = 0; - return *this; - } - - NodeID getId() const - { - return this->mPoolIndex; - } - - Json::Value getJsValue() - { - std::lock_guard _safe(this->mlock); - return this->_value; - } - - void getContext(const char *key, std::string &value) - { - std::lock_guard _safe(this->mlock); - _ContextType_ &ctx = this->_context.at(key); - value = ctx->asStringValue(); - } - - void getContext(const char *key, long &value) - { - std::lock_guard _safe(this->mlock); - _ContextType_ &ctx = this->_context.at(key); - value = ctx->asLongValue(); - } - - void setContext(const char *key, const char *buf) - { - std::lock_guard _safe(this->mlock); - _ContextType_ context(std::make_shared(buf)); - this->_context[key] = context; - } - - void setContext(const char *key, long l) - { - std::lock_guard _safe(this->mlock); - _ContextType_ context(std::make_shared(l)); - this->_context[key] = context; - } - - public: - TraceNode &operator=(const TraceNode &) = delete; - TraceNode(const TraceNode &) = delete; - - bool operator==(TraceNode const &_node) const - { - return this->mPoolIndex == _node.mPoolIndex; - } - - bool operator!=(TraceNode const &_node) const - { - return this->mPoolIndex != _node.mPoolIndex; - } - - public: - void AddTraceDetail(const char *key, const char *v) - { - std::lock_guard _safe(this->mlock); - this->_value[key] = v; - } - - void AddTraceDetail(const char *key, int v) - { - std::lock_guard _safe(this->mlock); - this->_value[key] = v; - } - - void AddTraceDetail(const char *key, uint64_t v) - { - std::lock_guard _safe(this->mlock); - this->_value[key] = v; - } - - void AddTraceDetail(const char *key, Json::Value &v) - { - std::lock_guard _safe(this->mlock); - this->_value[key] = v; - } - - void appendNodeValue(const char *key, const char *v) - { - std::lock_guard _safe(this->mlock); - this->_value[key].append(v); - } - - public: - void setOpt(const char *opt, va_list *args); - bool checkOpt(); - - private: - void parseOpt(std::string key, std::string value); - - void clearAttach(); - - void initId(NodeID &id); - - inline void resetRelative() - { - this->mNextId = E_INVALID_NODE; - this->mChildHeadId = E_INVALID_NODE; - this->mParentId = mPoolIndex; - this->mRootIndex = mPoolIndex; - this->_subTraceNodeMaxSize = MAX_SUB_TRACE_NODES_LIMIT; - } - - inline void resetStatus() - { - this->fetal_error_time = 0; - this->root_start_time = 0; - this->start_time = 0; - this->limit = E_TRACE_PASS; - this->cumulative_time = 0; - this->mHasExp = false; - } - - public: - // changes: expose _lock - std::mutex mlock; - - public: - int addRef() - { - _mRef++; - return _mRef.load(); - } - - int rmRef() - { - _mRef--; - return _mRef.load(); - } - - bool checkZoreRef() - { - return _mRef.load() == 0; - } - - public: - std::string ToString() - { - std::lock_guard _safe(this->mlock); - char pbuf[1024] = {0}; - int len = snprintf(pbuf, 1024, "mNextId:%d mChildListHeaderId:%d mParentId:%d mRootIndex:%d mPoolIndex:%d \n" - "start_time:%lu,fetal_error_time:%lu,limit:%lu,cumulative_time:%lu,root_start_time:%lu,mHasExp:%d \n" - "_mRef:%d\n" - "_value:%s \n" - "_context size:%lu,_endTraceCallback:%lu \n", - (int)this->mNextId, (int)this->mChildHeadId, (int)this->mParentId, (int)this->mRootIndex, (int)this->mPoolIndex, - this->start_time, this->fetal_error_time, this->limit, this->cumulative_time, this->root_start_time, this->mHasExp, - this->_mRef.load(), - this->_value.toStyledString().c_str(), - this->_context.size(), this->_endTraceCallback.size()); - return std::string(pbuf, len); - } - - private: - std::atomic _mRef; - int _subTraceNodeMaxSize; - - public: - // note: not tls, not a force limitation - inline void updateRootSubTraceSize() - { - if (this->_subTraceNodeMaxSize < 0) - { - throw std::out_of_range("current span reached max sub node limitation"); - } - else - { - this->_subTraceNodeMaxSize--; - } - } - - private: - Json::Value _value; - std::map _context; - std::vector> _endTraceCallback; - }; -} + private: + TraceNode *_traceNode; +}; + +typedef std::shared_ptr _ContextType_; +class TraceNode +{ + public: + NodeID mNextId; // equal brother node + NodeID mChildHeadId; // subtree/child tree + + NodeID mParentId; // parent Id [end_trace] avoiding re-add + NodeID mRootIndex; // highway to root node + NodeID mPoolIndex; + // int64_t mUID; + // int64_t mParentUID; + // int64_t mRootUID; + + uint64_t start_time; + uint64_t fetal_error_time; + uint64_t limit; + uint64_t cumulative_time; + uint64_t root_start_time; + bool mHasExp; + + public: + void startTimer(); + void endTimer(); + void wakeUp(); + + void convertToSpanEvent(); + void convertToSpan(); + + public: + void addChild(WrapperTraceNode &child); + void remove(); + + inline bool isRoot() const { return this->mRootIndex == mPoolIndex; } + + inline bool isLeaf() const { return this->mChildHeadId == E_INVALID_NODE; } + + public: + TraceNode() + { + this->mPoolIndex = E_INVALID_NODE; + this->mRootIndex = E_INVALID_NODE; + this->resetRelative(); + this->resetStatus(); + this->_mRef = 0; + } + + virtual ~TraceNode(); + + TraceNode &reset(NodeID id) + { + std::lock_guard _safe(this->mlock); + this->clearAttach(); + this->initId(id); + this->resetStatus(); + this->resetRelative(); + this->_mRef = 0; + return *this; + } + + NodeID getId() const { return this->mPoolIndex; } + + Json::Value getJsValue() + { + std::lock_guard _safe(this->mlock); + return this->_value; + } + + void getContext(const char *key, std::string &value) + { + std::lock_guard _safe(this->mlock); + _ContextType_ &ctx = this->_context.at(key); + value = ctx->asStringValue(); + } + + void getContext(const char *key, long &value) + { + std::lock_guard _safe(this->mlock); + _ContextType_ &ctx = this->_context.at(key); + value = ctx->asLongValue(); + } + + void setContext(const char *key, const char *buf) + { + std::lock_guard _safe(this->mlock); + _ContextType_ context(std::make_shared(buf)); + this->_context[key] = context; + } + + void setContext(const char *key, long l) + { + std::lock_guard _safe(this->mlock); + _ContextType_ context(std::make_shared(l)); + this->_context[key] = context; + } + + public: + TraceNode &operator=(const TraceNode &) = delete; + TraceNode(const TraceNode &) = delete; + + bool operator==(TraceNode const &_node) const { return this->mPoolIndex == _node.mPoolIndex; } + + bool operator!=(TraceNode const &_node) const { return this->mPoolIndex != _node.mPoolIndex; } + + public: + void AddTraceDetail(const char *key, const char *v) + { + std::lock_guard _safe(this->mlock); + this->_value[key] = v; + } + + void AddTraceDetail(const char *key, int v) + { + std::lock_guard _safe(this->mlock); + this->_value[key] = v; + } + + void AddTraceDetail(const char *key, uint64_t v) + { + std::lock_guard _safe(this->mlock); + this->_value[key] = v; + } + + void AddTraceDetail(const char *key, Json::Value &v) + { + std::lock_guard _safe(this->mlock); + this->_value[key] = v; + } + + void appendNodeValue(const char *key, const char *v) + { + std::lock_guard _safe(this->mlock); + this->_value[key].append(v); + } + + public: + void setOpt(const char *opt, va_list *args); + bool checkOpt(); + + private: + void parseOpt(std::string key, std::string value); + + void clearAttach(); + + void initId(NodeID &id); + + inline void resetRelative() + { + this->mNextId = E_INVALID_NODE; + this->mChildHeadId = E_INVALID_NODE; + this->mParentId = mPoolIndex; + this->mRootIndex = mPoolIndex; + this->_subTraceNodeMaxSize = MAX_SUB_TRACE_NODES_LIMIT; + } + + inline void resetStatus() + { + this->fetal_error_time = 0; + this->root_start_time = 0; + this->start_time = 0; + this->limit = E_TRACE_PASS; + this->cumulative_time = 0; + this->mHasExp = false; + } + + public: + // changes: expose _lock + std::mutex mlock; + + public: + int addRef() + { + _mRef++; + return _mRef.load(); + } + + int rmRef() + { + _mRef--; + return _mRef.load(); + } + + bool checkZoreRef() { return _mRef.load() == 0; } + + public: + std::string ToString() + { + std::lock_guard _safe(this->mlock); + char pbuf[1024] = {0}; + int len = snprintf(pbuf, 1024, + "mNextId:%d mChildListHeaderId:%d mParentId:%d mRootIndex:%d mPoolIndex:%d \n" + "start_time:%lu,fetal_error_time:%lu,limit:%lu,cumulative_time:%lu,root_start_time:%lu,mHasExp:%d \n" + "_mRef:%d\n" + "_value:%s \n" + "_context size:%lu,_endTraceCallback:%lu \n", + (int) this->mNextId, (int) this->mChildHeadId, (int) this->mParentId, (int) this->mRootIndex, (int) this->mPoolIndex, this->start_time, + this->fetal_error_time, this->limit, this->cumulative_time, this->root_start_time, this->mHasExp, this->_mRef.load(), + this->_value.toStyledString().c_str(), this->_context.size(), this->_endTraceCallback.size()); + return std::string(pbuf, len); + } + + private: + std::atomic _mRef; + int _subTraceNodeMaxSize; + + public: + // note: not tls, not a force limitation + inline void updateRootSubTraceSize() + { + if (this->_subTraceNodeMaxSize < 0) { + throw std::out_of_range("current span reached max sub node limitation"); + } else { + this->_subTraceNodeMaxSize--; + } + } + + private: + Json::Value _value; + std::map _context; + std::vector> _endTraceCallback; +}; +} // namespace NodePool #endif /* COMMON_SRC_TRACENODE_H_ */ diff --git a/common/src/Util/Helper.cpp b/common/src/Util/Helper.cpp index a1b1c630a..b8f9a3992 100644 --- a/common/src/Util/Helper.cpp +++ b/common/src/Util/Helper.cpp @@ -27,94 +27,75 @@ namespace Helper { - namespace Json = AliasJson; - using Cache::NodeTreeWriter; - using NodePool::PoolManager; - - static NodeTreeWriter _writer; - static ConnectionPool::SpanConnectionPool _con_pool; - static std::once_flag _pool_init_flag; - static Json::Value mergeChildren(WrapperTraceNode &node); - uint64_t get_current_msec_stamp() noexcept - { - std::chrono::time_point now = std::chrono::system_clock::now(); - time_point current = time_point_cast(now); - return current.time_since_epoch().count(); - } - - std::string node_tree_to_string(const Json::Value &value) - { - return _writer.write(value); - } - - static void gatcherChildDetailByReverse(Json::Value &detail, WrapperTraceNode &head) - { - if (head->mNextId != E_INVALID_NODE) - { - // TraceNode &next = PoolManager::getInstance().Take(head.mNextId); - WrapperTraceNode next = PoolManager::getInstance().GetWrapperNode(head->mNextId); - gatcherChildDetailByReverse(detail, next); - } - Json::Value childrenDetail = mergeChildren(head); - if (!childrenDetail.empty()) - { - detail.append(childrenDetail); - } - } - - Json::Value mergeChildren(WrapperTraceNode &node) - { - if (node->checkOpt() == false) - { - return Json::Value(); - } - else if (!node->isLeaf()) - { - // TraceNode &child = PoolManager::getInstance().Take(node.mChildHeadIndex); - WrapperTraceNode child = PoolManager::getInstance().GetWrapperNode(node->mChildHeadId); - - Json::Value childTraceDetail; - gatcherChildDetailByReverse(childTraceDetail, child); - node->AddTraceDetail("calls", childTraceDetail); - } - return node->getJsValue(); - } +namespace Json = AliasJson; +using Cache::NodeTreeWriter; +using NodePool::PoolManager; + +static NodeTreeWriter _writer; +static ConnectionPool::SpanConnectionPool _con_pool; +static std::once_flag _pool_init_flag; +static Json::Value mergeChildren(WrapperTraceNode &node); +uint64_t get_current_msec_stamp() noexcept +{ + std::chrono::time_point now = std::chrono::system_clock::now(); + time_point current = time_point_cast(now); + return current.time_since_epoch().count(); +} - Json::Value mergeTraceNodeTree(NodeID Id) noexcept - { - WrapperTraceNode root = PoolManager::getInstance().GetWrapperNode(Id); - return mergeTraceNodeTree(root); - } +std::string node_tree_to_string(const Json::Value &value) { return _writer.write(value); } - Json::Value mergeTraceNodeTree(WrapperTraceNode &root) - { - return mergeChildren(root); - } +static void gatcherChildDetailByReverse(Json::Value &detail, WrapperTraceNode &head) +{ + if (head->mNextId != E_INVALID_NODE) { + // TraceNode &next = PoolManager::getInstance().Take(head.mNextId); + WrapperTraceNode next = PoolManager::getInstance().GetWrapperNode(head->mNextId); + gatcherChildDetailByReverse(detail, next); + } + Json::Value childrenDetail = mergeChildren(head); + if (!childrenDetail.empty()) { detail.append(childrenDetail); } +} - Json::Value mergeTraceNodeTree(TraceNode &root) - { - WrapperTraceNode wroot(&root); - return mergeChildren(wroot); - } +Json::Value mergeChildren(WrapperTraceNode &node) +{ + if (node->checkOpt() == false) { + return Json::Value(); + } else if (!node->isLeaf()) { + // TraceNode &child = PoolManager::getInstance().Take(node.mChildHeadIndex); + WrapperTraceNode child = PoolManager::getInstance().GetWrapperNode(node->mChildHeadId); + + Json::Value childTraceDetail; + gatcherChildDetailByReverse(childTraceDetail, child); + node->AddTraceDetail("calls", childTraceDetail); + } + return node->getJsValue(); +} - TransConnection getConnection() - { +Json::Value mergeTraceNodeTree(NodeID Id) noexcept +{ + WrapperTraceNode root = PoolManager::getInstance().GetWrapperNode(Id); + return mergeTraceNodeTree(root); +} - std::call_once(_pool_init_flag, - []() - { _con_pool.initPool(global_agent_info.co_host); }); +Json::Value mergeTraceNodeTree(WrapperTraceNode &root) { return mergeChildren(root); } - return _con_pool.get(); - } +Json::Value mergeTraceNodeTree(TraceNode &root) +{ + WrapperTraceNode wroot(&root); + return mergeChildren(wroot); +} - void freeConnection(TransConnection &trans) - { +TransConnection getConnection() +{ + std::call_once(_pool_init_flag, []() { _con_pool.initPool(global_agent_info.co_host); }); - std::call_once(_pool_init_flag, - []() - { _con_pool.initPool(global_agent_info.co_host); }); + return _con_pool.get(); +} - return _con_pool.free(trans); - } +void freeConnection(TransConnection &trans) +{ + std::call_once(_pool_init_flag, []() { _con_pool.initPool(global_agent_info.co_host); }); + return _con_pool.free(trans); } + +} // namespace Helper diff --git a/common/src/common.cpp b/common/src/common.cpp index 451f9499d..54241a240 100644 --- a/common/src/common.cpp +++ b/common/src/common.cpp @@ -45,276 +45,205 @@ using NodePool::WrapperTraceNode; const static char *CLUSE = "clues"; static thread_local NodeID __tls_id = E_ROOT_NODE; -PPAgentT global_agent_info = { - "unix:./pinpoint_test.sock", - 1, - 10, - 1500, - 1, - nullptr, nullptr, nullptr}; +PPAgentT global_agent_info = {"unix:./pinpoint_test.sock", 1, 10, 1500, 1, nullptr, nullptr, nullptr}; // send current span with timeout static thread_local int _span_timeout = global_agent_info.timeout_ms; static std::function _SpanHandler_; -NodeID pinpoint_get_per_thread_id() -{ - return __tls_id; -} +NodeID pinpoint_get_per_thread_id() { return __tls_id; } -void pinpoint_update_per_thread_id(NodeID id) -{ - __tls_id = id; -} +void pinpoint_update_per_thread_id(NodeID id) { __tls_id = id; } static NodeID do_start_trace(NodeID id, const char *opt = nullptr, va_list *args = nullptr) { - if (id <= E_INVALID_NODE) - { - throw std::out_of_range("invalid node id"); - } - else if (id == E_ROOT_NODE) - { - TraceNode &r_node = PoolManager::getInstance().Take(); - r_node.startTimer(); - return r_node.mPoolIndex; - } - else - { - WrapperTraceNode parent = PoolManager::getInstance().GetWrapperNode(id); - - // get root node - WrapperTraceNode root = PoolManager::getInstance().GetWrapperNode(parent->mRootIndex); - - root->updateRootSubTraceSize(); - - // todo check subnode limit - WrapperTraceNode trace = PoolManager::getInstance().GetWrapperNode(); - trace->startTimer(); - parent->addChild(trace); - // pass opt - if (opt != nullptr) - { - trace->setOpt(opt, args); - } - return trace->mPoolIndex; - } + if (id <= E_INVALID_NODE) { + throw std::out_of_range("invalid node id"); + } else if (id == E_ROOT_NODE) { + TraceNode &r_node = PoolManager::getInstance().Take(); + r_node.startTimer(); + return r_node.mPoolIndex; + } else { + WrapperTraceNode parent = PoolManager::getInstance().GetWrapperNode(id); + + // get root node + WrapperTraceNode root = PoolManager::getInstance().GetWrapperNode(parent->mRootIndex); + + root->updateRootSubTraceSize(); + + // todo check subnode limit + WrapperTraceNode trace = PoolManager::getInstance().GetWrapperNode(); + trace->startTimer(); + parent->addChild(trace); + // pass opt + if (opt != nullptr) { trace->setOpt(opt, args); } + return trace->mPoolIndex; + } } static void flush_to_agent(std::string &span) { - TransConnection trans = Helper::getConnection(); + TransConnection trans = Helper::getConnection(); - if (!trans->copy_into_send_buffer(span)) - { - pp_trace("drop current span as it's too heavy! size:%lu", span.length()); - } - trans->trans_layer_pool(_span_timeout); - // if network not ready, span will send in next time. - Helper::freeConnection(trans); + if (!trans->copy_into_send_buffer(span)) { pp_trace("drop current span as it's too heavy! size:%lu", span.length()); } + trans->trans_layer_pool(_span_timeout); + // if network not ready, span will send in next time. + Helper::freeConnection(trans); } void sendSpan(NodeID rootId) { - const Json::Value trace = Helper::mergeTraceNodeTree(rootId); - std::string spanStr = Helper::node_tree_to_string(trace); - if (unlikely(_SpanHandler_ != nullptr)) - { - _SpanHandler_(spanStr.c_str()); - } - else - { - pp_trace("this span:(%s)", spanStr.c_str()); - flush_to_agent(spanStr); - } + const Json::Value trace = Helper::mergeTraceNodeTree(rootId); + std::string spanStr = Helper::node_tree_to_string(trace); + if (unlikely(_SpanHandler_ != nullptr)) { + _SpanHandler_(spanStr.c_str()); + } else { + pp_trace("this span:(%s)", spanStr.c_str()); + flush_to_agent(spanStr); + } } NodeID do_end_trace(NodeID Id) { - WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(Id); - if (r_node->isRoot()) - { - if (r_node->limit == E_TRACE_PASS) - { - r_node->endTimer(); - r_node->convertToSpan(); - sendSpan(Id); - } - else if (r_node->limit == E_TRACE_BLOCK) - { - pp_trace("current#%d span dropped,due to TRACE_BLOCK", r_node->getId()); - } - else - { - pp_trace("current#%d span dropped,due to limit=%ld", r_node->getId(), r_node->limit); - } - } - else - { - r_node->endTimer(); - r_node->convertToSpanEvent(); - return r_node->mParentId; - // check opt - // if (r_node->checkOpt() == true) - // { - // try - // { - // WrapperTraceNode r_parent = PoolManager::getInstance().GetWrapperNode(parentId); - // r_parent->addChild(r_node); - // return r_parent->mPoolIndex; - // } - // catch (const std::out_of_range &ex) - // { - // pp_trace("current#%d dropped,due to parent is end", Id); - // } - // catch (const std::exception &ex) - // { - // pp_trace("current#%d dropped,due to exception: %s", Id, ex.what()); - // } - // } - // else - // { - // pp_trace("current#%d dropped,due to checkOpt false", Id); - // } - } - // free current ndde tree - return E_ROOT_NODE; + WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(Id); + if (r_node->isRoot()) { + if (r_node->limit == E_TRACE_PASS) { + r_node->endTimer(); + r_node->convertToSpan(); + sendSpan(Id); + } else if (r_node->limit == E_TRACE_BLOCK) { + pp_trace("current#%d span dropped,due to TRACE_BLOCK", r_node->getId()); + } else { + pp_trace("current#%d span dropped,due to limit=%ld", r_node->getId(), r_node->limit); + } + } else { + r_node->endTimer(); + r_node->convertToSpanEvent(); + return r_node->mParentId; + // check opt + // if (r_node->checkOpt() == true) + // { + // try + // { + // WrapperTraceNode r_parent = PoolManager::getInstance().GetWrapperNode(parentId); + // r_parent->addChild(r_node); + // return r_parent->mPoolIndex; + // } + // catch (const std::out_of_range &ex) + // { + // pp_trace("current#%d dropped,due to parent is end", Id); + // } + // catch (const std::exception &ex) + // { + // pp_trace("current#%d dropped,due to exception: %s", Id, ex.what()); + // } + // } + // else + // { + // pp_trace("current#%d dropped,due to checkOpt false", Id); + // } + } + // free current ndde tree + return E_ROOT_NODE; } NodeID pinpoint_start_trace(NodeID parentId) { - try - { - NodeID childId = do_start_trace(parentId); - pp_trace("#%d pinpoint_start child #%d", parentId, childId); - return childId; - } - catch (const std::out_of_range &ex) - { - pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); - } - catch (const std::exception &ex) - { - pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); - } - return E_INVALID_NODE; + try { + NodeID childId = do_start_trace(parentId); + pp_trace("#%d pinpoint_start child #%d", parentId, childId); + return childId; + } catch (const std::out_of_range &ex) { + pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); + } catch (const std::exception &ex) { + pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); + } + return E_INVALID_NODE; } static NodeID do_wake_trace(NodeID &id) { - // routine - // 1. check id alive - // 2. check if it's a root node - // 3. update start time + // routine + // 1. check id alive + // 2. check if it's a root node + // 3. update start time - WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(id); + WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(id); - if (w_node->isRoot()) - { - pp_trace("#%d wake_trace failed, it's a root node", id); - return E_INVALID_NODE; - } + if (w_node->isRoot()) { + pp_trace("#%d wake_trace failed, it's a root node", id); + return E_INVALID_NODE; + } - w_node->wakeUp(); + w_node->wakeUp(); - return id; + return id; } int pinpoint_wake_trace(NodeID traceId) { - try - { - pp_trace("wake_trace #%d ", traceId); - return do_wake_trace(traceId); - } - catch (const std::out_of_range &ex) - { - pp_trace(" wake_trace#%d failed with %s", traceId, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" wake_trace#%d failed with %s", traceId, ex.what()); - } - catch (...) - { - pp_trace(" wake_trace#%d failed with unkonw reason", traceId); - } - return 0; + try { + pp_trace("wake_trace #%d ", traceId); + return do_wake_trace(traceId); + } catch (const std::out_of_range &ex) { + pp_trace(" wake_trace#%d failed with %s", traceId, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" wake_trace#%d failed with %s", traceId, ex.what()); + } catch (...) { + pp_trace(" wake_trace#%d failed with unkonw reason", traceId); + } + return 0; } int pinpoint_force_end_trace(NodeID id, int32_t timeout) { - try - { - _span_timeout = timeout; - while (id != E_ROOT_NODE) - { - id = pinpoint_end_trace(id); - if (id == E_INVALID_NODE) - break; - } - // back to normal - _span_timeout = global_agent_info.timeout_ms; - return 0; - } - catch (const std::out_of_range &) - { - pp_trace("#%d not found", id); + try { + _span_timeout = timeout; + while (id != E_ROOT_NODE) { + id = pinpoint_end_trace(id); + if (id == E_INVALID_NODE) break; } - catch (const std::exception &ex) - { - pp_trace("#%d end trace failed. %s", id, ex.what()); - } - return -1; + // back to normal + _span_timeout = global_agent_info.timeout_ms; + return 0; + } catch (const std::out_of_range &) { + pp_trace("#%d not found", id); + } catch (const std::exception &ex) { + pp_trace("#%d end trace failed. %s", id, ex.what()); + } + return -1; } int pinpoint_trace_is_root(NodeID _id) { - try - { - WrapperTraceNode node = PoolManager::getInstance().GetWrapperNode(_id); - return node->isRoot() ? (1) : (0); - } - catch (const std::out_of_range &) - { - pp_trace("#%d not found", _id); - } - catch (const std::exception &ex) - { - pp_trace("#%d end trace failed. %s", _id, ex.what()); - } - return -1; + try { + WrapperTraceNode node = PoolManager::getInstance().GetWrapperNode(_id); + return node->isRoot() ? (1) : (0); + } catch (const std::out_of_range &) { + pp_trace("#%d not found", _id); + } catch (const std::exception &ex) { + pp_trace("#%d end trace failed. %s", _id, ex.what()); + } + return -1; } NodeID pinpoint_end_trace(NodeID traceId) { - try - { - NodeID ret = do_end_trace(traceId); - if (ret == E_ROOT_NODE) - { - freeNodeTree(traceId); - } - pp_trace("#%d pinpoint_end_trace Done!", traceId); - return ret; - } - catch (const std::out_of_range &ex) - { - pp_trace("end_trace %d out_of_range exception: %s", traceId, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace("end_trace %d runtime_error: %s", traceId, ex.what()); - } - catch (const std::exception &ex) - { - pp_trace("end_trace #%d end trace failed. %s", traceId, ex.what()); - } + try { + NodeID ret = do_end_trace(traceId); + if (ret == E_ROOT_NODE) { freeNodeTree(traceId); } + pp_trace("#%d pinpoint_end_trace Done!", traceId); + return ret; + } catch (const std::out_of_range &ex) { + pp_trace("end_trace %d out_of_range exception: %s", traceId, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace("end_trace %d runtime_error: %s", traceId, ex.what()); + } catch (const std::exception &ex) { + pp_trace("end_trace #%d end trace failed. %s", traceId, ex.what()); + } - return E_INVALID_NODE; + return E_INVALID_NODE; } // static int do_remove_trace(NodeID traceId) @@ -340,379 +269,280 @@ NodeID pinpoint_end_trace(NodeID traceId) // } // } -uint64_t pinpoint_start_time(void) -{ - return (uint64_t)SafeSharedState::instance().getStartTime(); -} +uint64_t pinpoint_start_time(void) { return (uint64_t) SafeSharedState::instance().getStartTime(); } -int64_t generate_unique_id() -{ - return SafeSharedState::instance().generateUniqueId(); -} +int64_t generate_unique_id() { return SafeSharedState::instance().generateUniqueId(); } -void reset_unique_id(void) -{ - - return SafeSharedState::instance().resetUniqueId(); -} +void reset_unique_id(void) { return SafeSharedState::instance().resetUniqueId(); } uint64_t inline do_mark_current_trace_status(NodeID &_id, E_AGENT_STATUS status) { - WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(_id); - WrapperTraceNode w_root = PoolManager::getInstance().GetWrapperNode(w_node->mRootIndex); - pp_trace("change current#%d status, before:%lld,now:%d", w_root->getId(), w_root->limit, status); - return __sync_lock_test_and_set(&w_root->limit, status); + WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(_id); + WrapperTraceNode w_root = PoolManager::getInstance().GetWrapperNode(w_node->mRootIndex); + pp_trace("change current#%d status, before:%lld,now:%d", w_root->getId(), w_root->limit, status); + return __sync_lock_test_and_set(&w_root->limit, status); } uint64_t mark_current_trace_status(NodeID _id, int status) { - try - { - return do_mark_current_trace_status(_id, (E_AGENT_STATUS)status); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (...) - { - pp_trace(" %s#%d failed with unkonw reason", __func__, _id); - } - return 0; + try { + return do_mark_current_trace_status(_id, (E_AGENT_STATUS) status); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (...) { + pp_trace(" %s#%d failed with unkonw reason", __func__, _id); + } + return 0; } -int check_tracelimit(int64_t timestamp) -{ - return SafeSharedState::instance().checkTraceLimit(timestamp) ? (1) : (0); -} +int check_tracelimit(int64_t timestamp) { return SafeSharedState::instance().checkTraceLimit(timestamp) ? (1) : (0); } static inline WrapperTraceNode locate_node_by_loc(NodeID _id, E_NODE_LOC flag) { - WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(_id); - if (flag == E_LOC_ROOT) - { - return PoolManager::getInstance().GetWrapperNode(w_node->mRootIndex); - } - else - { - return w_node; - } + WrapperTraceNode w_node = PoolManager::getInstance().GetWrapperNode(_id); + if (flag == E_LOC_ROOT) { + return PoolManager::getInstance().GetWrapperNode(w_node->mRootIndex); + } else { + return w_node; + } } static void do_add_clue(NodeID _id, const char *key, const char *value, E_NODE_LOC flag) { - WrapperTraceNode w_node = locate_node_by_loc(_id, flag); - w_node->AddTraceDetail(key, value); - pp_trace("#%d add clue key:%s value:%s", _id, key, value); + WrapperTraceNode w_node = locate_node_by_loc(_id, flag); + w_node->AddTraceDetail(key, value); + pp_trace("#%d add clue key:%s value:%s", _id, key, value); } static void do_add_clues(NodeID _id, const char *key, const char *value, E_NODE_LOC flag) { - WrapperTraceNode w_node = locate_node_by_loc(_id, flag); + WrapperTraceNode w_node = locate_node_by_loc(_id, flag); - std::string cvalue = ""; - cvalue += key; - cvalue += ':'; - cvalue += value; - w_node->appendNodeValue(CLUSE, cvalue.c_str()); - pp_trace("#%d add clues:%s:%s", _id, key, value); + std::string cvalue = ""; + cvalue += key; + cvalue += ':'; + cvalue += value; + w_node->appendNodeValue(CLUSE, cvalue.c_str()); + pp_trace("#%d add clues:%s:%s", _id, key, value); } void pinpoint_add_clues(NodeID _id, const char *key, const char *value, E_NODE_LOC flag) { - try - { - do_add_clues(_id, key, value, flag); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed.Reason %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed.Reason %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (...) - { - pp_trace(" %s#%d failed.Reason: unknown reason,parameters:%s:%s", __func__, _id, key, value); - } + try { + do_add_clues(_id, key, value, flag); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed.Reason %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed.Reason %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (...) { + pp_trace(" %s#%d failed.Reason: unknown reason,parameters:%s:%s", __func__, _id, key, value); + } } void pinpoint_add_clue(NodeID _id, const char *key, const char *value, E_NODE_LOC flag) { - try - { - do_add_clue(_id, key, value, flag); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed. Reason: %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed. Reason: %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (...) - { - pp_trace(" %s#%d failed. Reason: unknow reason,parameters:%s:%s", __func__, _id, key, value); - } + try { + do_add_clue(_id, key, value, flag); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed. Reason: %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed. Reason: %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (...) { + pp_trace(" %s#%d failed. Reason: unknow reason,parameters:%s:%s", __func__, _id, key, value); + } } static inline void do_set_context_key(NodeID _id, const char *key, const char *value) { - WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); - w_node->setContext(key, value); + WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); + w_node->setContext(key, value); } static int do_get_context_key(NodeID _id, const char *key, char *pbuf, int buf_size) { - WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); - std::string value; - w_node->getContext(key, value); - if (pbuf != nullptr && buf_size > (int)value.size()) - { - strncpy(pbuf, value.c_str(), buf_size); - return (int)value.size(); - } - else - { - pp_trace("#%d get context key:%s failed. buffer is not enough", _id, key); - return -1; - } + WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); + std::string value; + w_node->getContext(key, value); + if (pbuf != nullptr && buf_size > (int) value.size()) { + strncpy(pbuf, value.c_str(), buf_size); + return (int) value.size(); + } else { + pp_trace("#%d get context key:%s failed. buffer is not enough", _id, key); + return -1; + } } void pinpoint_set_context_key(NodeID _id, const char *key, const char *value) { - try - { - do_set_context_key(_id, key, value); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with out_of_range. %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with runtime_error. %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed with %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); - } + try { + do_set_context_key(_id, key, value); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with out_of_range. %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with runtime_error. %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed with %s,parameters:%s:%s", __func__, _id, ex.what(), key, value); + } } static void do_set_long_key(NodeID id, const char *key, long l) { - WrapperTraceNode w_node = locate_node_by_loc(id, E_LOC_ROOT); - w_node->setContext(key, l); + WrapperTraceNode w_node = locate_node_by_loc(id, E_LOC_ROOT); + w_node->setContext(key, l); } void pinpoint_set_context_long(NodeID _id, const char *key, long l) { - try - { - do_set_long_key(_id, key, l); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } + try { + do_set_long_key(_id, key, l); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } } static int do_get_long_key(NodeID _id, const char *key, long *l) { - WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); - if (l != nullptr) - { - long v; - w_node->getContext(key, v); - *l = v; - } - return 0; + WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); + if (l != nullptr) { + long v; + w_node->getContext(key, v); + *l = v; + } + return 0; } int pinpoint_get_context_long(NodeID _id, const char *key, long *l) { - try - { - do_get_long_key(_id, key, l); - return 0; - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - return 1; + try { + do_get_long_key(_id, key, l); + return 0; + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } + return 1; } int pinpoint_get_context_key(NodeID _id, const char *key, char *pbuf, int buf_size) { - try - { - return do_get_context_key(_id, key, pbuf, buf_size); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); - } - return -1; + try { + return do_get_context_key(_id, key, pbuf, buf_size); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed with %s, parameters:%s", __func__, _id, ex.what(), key); + } + return -1; } void do_catch_error(NodeID _id, const char *msg, const char *error_filename, uint32_t error_lineno) { - WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); + WrapperTraceNode w_node = locate_node_by_loc(_id, E_LOC_ROOT); - Json::Value eMsg; - eMsg["msg"] = msg; - eMsg["file"] = error_filename; - eMsg["line"] = error_lineno; - w_node->AddTraceDetail("ERR", eMsg); + Json::Value eMsg; + eMsg["msg"] = msg; + eMsg["file"] = error_filename; + eMsg["line"] = error_lineno; + w_node->AddTraceDetail("ERR", eMsg); } void catch_error(NodeID _id, const char *msg, const char *error_filename, uint32_t error_lineno) { - try - { - do_catch_error(_id, msg, error_filename, error_lineno); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); - } + try { + do_catch_error(_id, msg, error_filename, error_lineno); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed with %s", __func__, _id, ex.what()); + } } const char *pinpoint_agent_version() { #ifdef AGENT_VERSION - static const char *_version_ = AGENT_VERSION; + static const char *_version_ = AGENT_VERSION; #else - static const char *_version_ = "x.x.x"; + static const char *_version_ = "x.x.x"; #endif - return _version_; + return _version_; } NodeID pinpoint_start_traceV1(NodeID parentId, const char *opt, ...) { - try - { - va_list args; - va_start(args, opt); - NodeID childId = do_start_trace(parentId, opt, &args); - va_end(args); - pp_trace("#%d pinpoint_start_traceV1 child #%d", parentId, childId); - return childId; - } - catch (const std::out_of_range &ex) - { - pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); - } - catch (const std::runtime_error &ex) - { - pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); - } - catch (...) - { - pp_trace(" start_trace#%d failed with unkonw reason", parentId); - } - return E_INVALID_NODE; + try { + va_list args; + va_start(args, opt); + NodeID childId = do_start_trace(parentId, opt, &args); + va_end(args); + pp_trace("#%d pinpoint_start_traceV1 child #%d", parentId, childId); + return childId; + } catch (const std::out_of_range &ex) { + pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); + } catch (const std::runtime_error &ex) { + pp_trace(" start_trace#%d failed with %s", parentId, ex.what()); + } catch (...) { + pp_trace(" start_trace#%d failed with unkonw reason", parentId); + } + return E_INVALID_NODE; } static void do_add_exp(NodeID _id, const char *value) { - WrapperTraceNode w_root = locate_node_by_loc(_id, E_LOC_CURRENT); - w_root->AddTraceDetail("EXP", value); - w_root->mHasExp = true; - pp_trace("#%d add exp value:%s", _id, value); + WrapperTraceNode w_root = locate_node_by_loc(_id, E_LOC_CURRENT); + w_root->AddTraceDetail("EXP", value); + w_root->mHasExp = true; + pp_trace("#%d add exp value:%s", _id, value); } void pinpoint_add_exception(NodeID traceId, const char *exp) { - try - { - do_add_exp(traceId, exp); - } - catch (const std::out_of_range &ex) - { - pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); - } - catch (const std::runtime_error &ex) - { - pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); - } - catch (const std::exception &ex) - { - pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); - } + try { + do_add_exp(traceId, exp); + } catch (const std::out_of_range &ex) { + pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); + } catch (const std::runtime_error &ex) { + pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); + } catch (const std::exception &ex) { + pp_trace(" %s#%d failed. Reason: %s,parameters:%s", __func__, traceId, ex.what(), exp); + } } void register_span_handler(void (*handler)(const char *)) { - if (likely(handler != nullptr)) - { - _SpanHandler_ = std::bind(handler, std::placeholders::_1); - } + if (likely(handler != nullptr)) { _SpanHandler_ = std::bind(handler, std::placeholders::_1); } } void show_status(void) { - Json::Value status; - status["pool_total_node"] = PoolManager::getInstance().totoalNodesCount(); - status["pool_free_node"] = PoolManager::getInstance().freeNodesCount(); - status["common_libary_version"] = pinpoint_agent_version(); - auto add_alive_node_fun = [&status](TraceNode &node) - { - status["pool_alive_nodes"].append(node.mPoolIndex); - }; - PoolManager::getInstance().foreachAliveNode(std::bind(add_alive_node_fun, std::placeholders::_1)); + Json::Value status; + status["pool_total_node"] = PoolManager::getInstance().totoalNodesCount(); + status["pool_free_node"] = PoolManager::getInstance().freeNodesCount(); + status["common_libary_version"] = pinpoint_agent_version(); + auto add_alive_node_fun = [&status](TraceNode &node) { status["pool_alive_nodes"].append(node.mPoolIndex); }; + PoolManager::getInstance().foreachAliveNode(std::bind(add_alive_node_fun, std::placeholders::_1)); - fprintf(stderr, "%s\n", status.toStyledString().c_str()); + fprintf(stderr, "%s\n", status.toStyledString().c_str()); } void debug_nodeid(NodeID id) { - try - { - WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(id); - fprintf(stderr, "nodeid#%d: { value:%s }", id, r_node->ToString().c_str()); - } - catch (const std::exception &ex) - { - pp_trace(" debug_nodeid:#%d Reason: %s", id, ex.what()); - } + try { + WrapperTraceNode r_node = PoolManager::getInstance().GetWrapperNode(id); + fprintf(stderr, "nodeid#%d: { value:%s }", id, r_node->ToString().c_str()); + } catch (const std::exception &ex) { + pp_trace(" debug_nodeid:#%d Reason: %s", id, ex.what()); + } } \ No newline at end of file diff --git a/common/test/test_chunk.cc b/common/test/test_chunk.cc index 742630eb2..1cd0f3cd4 100644 --- a/common/test/test_chunk.cc +++ b/common/test/test_chunk.cc @@ -4,62 +4,61 @@ using namespace testing; using Cache::Chunks; -static int checkData(const void* buf,uint length,void* dst) +static int checkData(const void* buf, uint length, void* dst) { - int ret = 0; - if(length < 25) - { - ret = length; - }else{ - ret = length /2; - } - std::string * str = (std::string*)dst; - str->append((const char*)buf,ret); + int ret = 0; + if (length < 25) { + ret = length; + } else { + ret = length / 2; + } + std::string* str = (std::string*) dst; + str->append((const char*) buf, ret); - return ret; + return ret; } TEST(chunk, all_in_one) { - Chunks chunks(1024*4,128); - std::string out,ret; -// int size = 0; - // user random data - char buf1[1024]; - char buf2[1024]; - char buf3[1024]; + Chunks chunks(1024 * 4, 128); + std::string out, ret; + // int size = 0; + // user random data + char buf1[1024]; + char buf2[1024]; + char buf3[1024]; - chunks.copyDataIntoChunks(buf1,1024); - chunks.copyDataIntoChunks(buf2,1024); - chunks.copyDataIntoChunks(buf3,1024); - out.append(buf1,1024); - out.append(buf2,1024); - out.append(buf3,1024); + chunks.copyDataIntoChunks(buf1, 1024); + chunks.copyDataIntoChunks(buf2, 1024); + chunks.copyDataIntoChunks(buf3, 1024); + out.append(buf1, 1024); + out.append(buf2, 1024); + out.append(buf3, 1024); - // in and out - chunks.drainOutWithPipe(std::bind(&checkData,std::placeholders::_1,std::placeholders::_2,&ret)); + // in and out + chunks.drainOutWithPipe(std::bind(&checkData, std::placeholders::_1, std::placeholders::_2, &ret)); - EXPECT_TRUE(ret == out); + EXPECT_TRUE(ret == out); - // copy until full - chunks.copyDataIntoChunks(buf1,1024); - chunks.copyDataIntoChunks(buf2,1024); - chunks.copyDataIntoChunks(buf3,1024); - EXPECT_FALSE(chunks.checkCapacity(1025)); + // copy until full + chunks.copyDataIntoChunks(buf1, 1024); + chunks.copyDataIntoChunks(buf2, 1024); + chunks.copyDataIntoChunks(buf3, 1024); + EXPECT_FALSE(chunks.checkCapacity(1025)); - chunks.copyDataIntoChunks(buf3,1024); - EXPECT_TRUE(chunks.copyDataIntoChunks(buf3,1024) == 0 ); + chunks.copyDataIntoChunks(buf3, 1024); + EXPECT_TRUE(chunks.copyDataIntoChunks(buf3, 1024) == 0); - out.clear(); - out.append(buf1,1024); - out.append(buf2,1024); - out.append(buf3,1024); - out.append(buf3,1024); - out.append(buf3,1024); + out.clear(); + out.append(buf1, 1024); + out.append(buf2, 1024); + out.append(buf3, 1024); + out.append(buf3, 1024); + out.append(buf3, 1024); - ret.clear(); - chunks.drainOutWithPipe(std::bind(&checkData,std::placeholders::_1,std::placeholders::_2,&ret)); - EXPECT_TRUE(chunks.getAllocSize() == 0); - EXPECT_TRUE(ret == out); + ret.clear(); + chunks.drainOutWithPipe(std::bind(&checkData, std::placeholders::_1, std::placeholders::_2, &ret)); + EXPECT_TRUE(chunks.getAllocSize() == 0); + EXPECT_TRUE(ret == out); } diff --git a/common/test/test_common.cc b/common/test/test_common.cc index 1c5d517cc..916082ef8 100644 --- a/common/test/test_common.cc +++ b/common/test/test_common.cc @@ -8,181 +8,167 @@ using namespace testing; std::string ouputMsg; -void cc_log_error_cb(char *msg) -{ - ouputMsg += msg; -} +void cc_log_error_cb(char *msg) { ouputMsg += msg; } TEST(common, uid_all_in_one) { - // register_error_cb(cc_log_error_cb); - // test_trace(); - int64_t startId = generate_unique_id(); - generate_unique_id(); - generate_unique_id(); - generate_unique_id(); - EXPECT_EQ(generate_unique_id(), 4 + startId); + // register_error_cb(cc_log_error_cb); + // test_trace(); + int64_t startId = generate_unique_id(); + generate_unique_id(); + generate_unique_id(); + generate_unique_id(); + EXPECT_EQ(generate_unique_id(), 4 + startId); #define _100K 100000 - pid_t pid = fork(); - if (pid == 0) - { - for (int i = 0; i < _100K; i++) - generate_unique_id(); - exit(0); - } - - for (int i = 0; i < _100K; i++) - generate_unique_id(); - waitpid(pid, NULL, 0); - //[0~9999] - EXPECT_EQ(generate_unique_id(), (startId + 2 * _100K + 5)); + pid_t pid = fork(); + if (pid == 0) { + for (int i = 0; i < _100K; i++) generate_unique_id(); + exit(0); + } + + for (int i = 0; i < _100K; i++) generate_unique_id(); + waitpid(pid, NULL, 0); + //[0~9999] + EXPECT_EQ(generate_unique_id(), (startId + 2 * _100K + 5)); } TEST(common, start_end_trace) { - NodeID id = pinpoint_start_trace(E_ROOT_NODE); - mark_current_trace_status(id, E_OFFLINE); - EXPECT_EQ(pinpoint_trace_is_root(id), 1); - id = pinpoint_start_trace(id); - EXPECT_EQ(pinpoint_trace_is_root(id), 0); - mark_current_trace_status(id, E_OFFLINE); - EXPECT_EQ(pinpoint_trace_is_root(NodeID(-1023)), -1); - EXPECT_EQ(pinpoint_trace_is_root(NodeID(1023)), -1); - id = pinpoint_start_trace(id); - - mark_current_trace_status(id, E_TRACE_PASS); - catch_error(id, "sdfasfas", "fsafdsfasd", 234); - id = pinpoint_end_trace(id); - - id = pinpoint_end_trace(id); - - id = pinpoint_end_trace(id); - EXPECT_EQ(id, 0); + NodeID id = pinpoint_start_trace(E_ROOT_NODE); + mark_current_trace_status(id, E_OFFLINE); + EXPECT_EQ(pinpoint_trace_is_root(id), 1); + id = pinpoint_start_trace(id); + EXPECT_EQ(pinpoint_trace_is_root(id), 0); + mark_current_trace_status(id, E_OFFLINE); + EXPECT_EQ(pinpoint_trace_is_root(NodeID(-1023)), -1); + EXPECT_EQ(pinpoint_trace_is_root(NodeID(1023)), -1); + id = pinpoint_start_trace(id); + + mark_current_trace_status(id, E_TRACE_PASS); + catch_error(id, "sdfasfas", "fsafdsfasd", 234); + id = pinpoint_end_trace(id); + + id = pinpoint_end_trace(id); + + id = pinpoint_end_trace(id); + EXPECT_EQ(id, 0); } TEST(common, context_check) { - NodeID id = pinpoint_start_trace(E_ROOT_NODE); - std::string str = "fdafadf"; - pinpoint_add_clues(id, "fasdfas", str.c_str(), E_LOC_CURRENT); - pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); - pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); - pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); - - id = pinpoint_start_trace(id); - pinpoint_add_clue(id, "global", str.c_str(), E_LOC_ROOT); - id = pinpoint_end_trace(id); - str.clear(); - str = "fadfaffadf"; - pinpoint_set_context_key(id, "adfadf", str.c_str()); - str += "35486we32"; - pinpoint_set_context_key(id, "adfadf23", str.c_str()); - str.clear(); - char buf[1024] = {0}; - pinpoint_get_context_key(id, "adfadf23", buf, 1024); - - EXPECT_STREQ(buf, "fadfaffadf35486we32"); - pinpoint_get_context_key(id, "adfadf", buf, 1024); - - EXPECT_STREQ(buf, "fadfaffadf"); - - pinpoint_set_context_long(id, "1024", 1024); - pinpoint_set_context_long(NodeID(0), "1024", 1024); - pinpoint_set_context_long(NodeID(1205), "1024", 1024); - pinpoint_set_context_key(id, "adfadf23", "fadfaffadf"); - long value; - EXPECT_EQ(pinpoint_get_context_long(id, "1024", &value), 0); - EXPECT_EQ(value, 1024); - pinpoint_end_trace(id); + NodeID id = pinpoint_start_trace(E_ROOT_NODE); + std::string str = "fdafadf"; + pinpoint_add_clues(id, "fasdfas", str.c_str(), E_LOC_CURRENT); + pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); + pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); + pinpoint_add_clue(id, "fasdfas", str.c_str(), E_LOC_CURRENT); + + id = pinpoint_start_trace(id); + pinpoint_add_clue(id, "global", str.c_str(), E_LOC_ROOT); + id = pinpoint_end_trace(id); + str.clear(); + str = "fadfaffadf"; + pinpoint_set_context_key(id, "adfadf", str.c_str()); + str += "35486we32"; + pinpoint_set_context_key(id, "adfadf23", str.c_str()); + str.clear(); + char buf[1024] = {0}; + pinpoint_get_context_key(id, "adfadf23", buf, 1024); + + EXPECT_STREQ(buf, "fadfaffadf35486we32"); + pinpoint_get_context_key(id, "adfadf", buf, 1024); + + EXPECT_STREQ(buf, "fadfaffadf"); + + pinpoint_set_context_long(id, "1024", 1024); + pinpoint_set_context_long(NodeID(0), "1024", 1024); + pinpoint_set_context_long(NodeID(1205), "1024", 1024); + pinpoint_set_context_key(id, "adfadf23", "fadfaffadf"); + long value; + EXPECT_EQ(pinpoint_get_context_long(id, "1024", &value), 0); + EXPECT_EQ(value, 1024); + pinpoint_end_trace(id); } TEST(common, error_checking) { - NodeID id = pinpoint_start_trace(E_ROOT_NODE); - EXPECT_EQ(pinpoint_trace_is_root(id), 1); - id = pinpoint_end_trace(id); - EXPECT_EQ(id, 0); + NodeID id = pinpoint_start_trace(E_ROOT_NODE); + EXPECT_EQ(pinpoint_trace_is_root(id), 1); + id = pinpoint_end_trace(id); + EXPECT_EQ(id, 0); - id = pinpoint_start_trace(NodeID(1280)); - EXPECT_EQ(id, E_INVALID_NODE); + id = pinpoint_start_trace(NodeID(1280)); + EXPECT_EQ(id, E_INVALID_NODE); } static void test_per_thread_id_odd() { - NodeID id = pinpoint_get_per_thread_id(); - EXPECT_EQ(id, 0); - id = NodeID(1); - for (int i = 1; i < 10000; i++) - { - int index = (int)id; - index += 2; - id = NodeID(index); - pinpoint_update_per_thread_id(id); - std::this_thread::sleep_for(std::chrono::microseconds(1)); - EXPECT_EQ(pinpoint_get_per_thread_id(), i * 2 + 1); - } + NodeID id = pinpoint_get_per_thread_id(); + EXPECT_EQ(id, 0); + id = NodeID(1); + for (int i = 1; i < 10000; i++) { + int index = (int) id; + index += 2; + id = NodeID(index); + pinpoint_update_per_thread_id(id); + std::this_thread::sleep_for(std::chrono::microseconds(1)); + EXPECT_EQ(pinpoint_get_per_thread_id(), i * 2 + 1); + } } static void test_per_thread_id_even() { - NodeID id = pinpoint_get_per_thread_id(); - EXPECT_EQ(id, 0); - - for (int i = 1; i < 10000; i++) - { - int index = (int)id; - index += 2; - id = (NodeID)index; - - pinpoint_update_per_thread_id(id); - std::this_thread::sleep_for(std::chrono::microseconds(1)); - EXPECT_EQ(pinpoint_get_per_thread_id(), i * 2); - } + NodeID id = pinpoint_get_per_thread_id(); + EXPECT_EQ(id, 0); + + for (int i = 1; i < 10000; i++) { + int index = (int) id; + index += 2; + id = (NodeID) index; + + pinpoint_update_per_thread_id(id); + std::this_thread::sleep_for(std::chrono::microseconds(1)); + EXPECT_EQ(pinpoint_get_per_thread_id(), i * 2); + } } TEST(common, per_threadid) { - std::thread f1(test_per_thread_id_odd); - std::thread f2(test_per_thread_id_even); - f1.join(); - f2.join(); + std::thread f1(test_per_thread_id_odd); + std::thread f2(test_per_thread_id_even); + f1.join(); + f2.join(); } TEST(common, force_end_trace) { - NodeID id = pinpoint_start_trace(E_ROOT_NODE); - id = pinpoint_end_trace(id); - id = pinpoint_start_trace(id); - id = pinpoint_start_trace(id); - id = pinpoint_start_trace(id); - id = pinpoint_start_trace(id); - id = pinpoint_end_trace(id); - id = pinpoint_end_trace(id); - EXPECT_NE(id, 0); - int ret = pinpoint_force_end_trace(id, 300); - EXPECT_EQ(ret, 0); - id = NodeID(809999); - pinpoint_force_end_trace(id, 300); - pinpoint_force_end_trace(NodeID(-1235), 300); - pinpoint_force_end_trace(NodeID(0), 300); - pinpoint_force_end_trace(NodeID(1), 300); - pinpoint_force_end_trace(NodeID(-1), 300); + NodeID id = pinpoint_start_trace(E_ROOT_NODE); + id = pinpoint_end_trace(id); + id = pinpoint_start_trace(id); + id = pinpoint_start_trace(id); + id = pinpoint_start_trace(id); + id = pinpoint_start_trace(id); + id = pinpoint_end_trace(id); + id = pinpoint_end_trace(id); + EXPECT_NE(id, 0); + int ret = pinpoint_force_end_trace(id, 300); + EXPECT_EQ(ret, 0); + id = NodeID(809999); + pinpoint_force_end_trace(id, 300); + pinpoint_force_end_trace(NodeID(-1235), 300); + pinpoint_force_end_trace(NodeID(0), 300); + pinpoint_force_end_trace(NodeID(1), 300); + pinpoint_force_end_trace(NodeID(-1), 300); } -TEST(common, version) -{ - EXPECT_STREQ(pinpoint_agent_version(), AGENT_VERSION); -} +TEST(common, version) { EXPECT_STREQ(pinpoint_agent_version(), AGENT_VERSION); } //./bin/unittest --gtest_filter=common.id_1 TEST(common, id_1) { - NodeID id = pinpoint_start_trace(E_ROOT_NODE); - for (int i = 0; i < 1280; i++) - { - id = pinpoint_start_trace(id); - } - pinpoint_set_context_long(id, "1024", 1024); + NodeID id = pinpoint_start_trace(E_ROOT_NODE); + for (int i = 0; i < 1280; i++) { id = pinpoint_start_trace(id); } + pinpoint_set_context_long(id, "1024", 1024); } diff --git a/common/test/test_genUniqId.cc b/common/test/test_genUniqId.cc index 40237a65c..4e9cdd0c9 100644 --- a/common/test/test_genUniqId.cc +++ b/common/test/test_genUniqId.cc @@ -7,37 +7,35 @@ using namespace testing; -TEST(common,unique_id) +TEST(common, unique_id) { - static const int TIMES=10000000; - int64_t last=-1; - // reset the unique id - reset_unique_id(); - pid_t pid = fork(); - if(pid == 0){ // child - for(int i=0;i #include "common.h" -void remove_shm_file() -{ - shm_unlink("pinpoint-php.shm"); -} +void remove_shm_file() { shm_unlink("pinpoint-php.shm"); } int main(int argc, char **argv) { - std::atexit(remove_shm_file); - register_error_cb(NULL); - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + std::atexit(remove_shm_file); + register_error_cb(NULL); + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } \ No newline at end of file diff --git a/common/test/test_node.cc b/common/test/test_node.cc index 1a0cfbd86..4d9abf046 100644 --- a/common/test/test_node.cc +++ b/common/test/test_node.cc @@ -18,409 +18,381 @@ std::mutex cv_m; std::condition_variable cv; NodeID rootId = E_ROOT_NODE; -int usedNode() -{ - return PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); -} +int usedNode() { return PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); } // note: as it known, there may leak some node void func() { - std::unique_lock lk(cv_m); - cv.wait(lk); - pinpoint_add_clues(rootId, "xxxx", "bbbbbbss", E_LOC_CURRENT); - pinpoint_add_clue(rootId, "xxx", "bbbbbb", E_LOC_CURRENT); - for (int i = 0; i < 100; ++i) - { - rootId = pinpoint_start_trace(rootId); - pinpoint_set_context_key(rootId, "xxxx", "bbbbbb"); - std::this_thread::yield(); - char buf[1024]; - pinpoint_get_context_key(rootId, "xxxx", buf, 1024); - std::cout << "read value:" << buf << " "; - pinpoint_add_clues(rootId, "xxxx", "bbbbbbss", E_LOC_CURRENT); - std::this_thread::yield(); - pinpoint_add_clue(rootId, "xxx", "bbbbbb", E_LOC_CURRENT); - std::this_thread::yield(); - rootId = pinpoint_end_trace(rootId); - std::this_thread::yield(); - } + std::unique_lock lk(cv_m); + cv.wait(lk); + pinpoint_add_clues(rootId, "xxxx", "bbbbbbss", E_LOC_CURRENT); + pinpoint_add_clue(rootId, "xxx", "bbbbbb", E_LOC_CURRENT); + for (int i = 0; i < 100; ++i) { + rootId = pinpoint_start_trace(rootId); + pinpoint_set_context_key(rootId, "xxxx", "bbbbbb"); + std::this_thread::yield(); + char buf[1024]; + pinpoint_get_context_key(rootId, "xxxx", buf, 1024); + std::cout << "read value:" << buf << " "; pinpoint_add_clues(rootId, "xxxx", "bbbbbbss", E_LOC_CURRENT); + std::this_thread::yield(); pinpoint_add_clue(rootId, "xxx", "bbbbbb", E_LOC_CURRENT); + std::this_thread::yield(); + rootId = pinpoint_end_trace(rootId); + std::this_thread::yield(); + } + pinpoint_add_clues(rootId, "xxxx", "bbbbbbss", E_LOC_CURRENT); + pinpoint_add_clue(rootId, "xxx", "bbbbbb", E_LOC_CURRENT); } TEST(node, multipleThread) { - // no crash, works fine - NodeID root = pinpoint_start_trace(E_ROOT_NODE); + // no crash, works fine + NodeID root = pinpoint_start_trace(E_ROOT_NODE); - std::vector threads; + std::vector threads; - for (int i = 0; i < 10; i++) - { - threads.push_back(std::thread(func)); - } + for (int i = 0; i < 10; i++) { threads.push_back(std::thread(func)); } - sleep(2); - cv.notify_all(); + sleep(2); + cv.notify_all(); - for (int i = 0; i < 10; i++) - { - threads[i].join(); - } - pinpoint_end_trace(root); - pinpoint_end_trace(root); - // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); + for (int i = 0; i < 10; i++) { threads[i].join(); } + pinpoint_end_trace(root); + pinpoint_end_trace(root); + // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); } TEST(node, wakeTrace) { - NodeID root = pinpoint_start_trace(E_ROOT_NODE); - NodeID child1 = pinpoint_start_trace(root); + NodeID root = pinpoint_start_trace(E_ROOT_NODE); + NodeID child1 = pinpoint_start_trace(root); - pinpoint_end_trace(child1); + pinpoint_end_trace(child1); - pinpoint_wake_trace(child1); - pinpoint_wake_trace(root); - pinpoint_wake_trace(NodeID(159)); - pinpoint_wake_trace(NodeID(1027)); - // do something - sleep(1); - pinpoint_end_trace(child1); + pinpoint_wake_trace(child1); + pinpoint_wake_trace(root); + pinpoint_wake_trace(NodeID(159)); + pinpoint_wake_trace(NodeID(1027)); + // do something + sleep(1); + pinpoint_end_trace(child1); - pinpoint_end_trace(root); - // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); + pinpoint_end_trace(root); + // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); } void test_opt(TraceNode &node, const char *opt, ...) { - va_list args; - va_start(args, opt); - node.setOpt(opt, &args); - va_end(args); + va_list args; + va_start(args, opt); + node.setOpt(opt, &args); + va_end(args); } TEST(node, opt) { - TraceNode &node = PoolManager::getInstance().Take(); + TraceNode &node = PoolManager::getInstance().Take(); - test_opt(node, "TraceMinTimeMs:23", "TraceOnlyException", nullptr); + test_opt(node, "TraceMinTimeMs:23", "TraceOnlyException", nullptr); - node.cumulative_time = 22; - EXPECT_FALSE(node.checkOpt()); - node.cumulative_time = 23; - EXPECT_TRUE(node.checkOpt()); + node.cumulative_time = 22; + EXPECT_FALSE(node.checkOpt()); + node.cumulative_time = 23; + EXPECT_TRUE(node.checkOpt()); - node.cumulative_time = 0; - node.mHasExp = true; - EXPECT_TRUE(node.checkOpt()); - node.mHasExp = false; - EXPECT_FALSE(node.checkOpt()); + node.cumulative_time = 0; + node.mHasExp = true; + EXPECT_TRUE(node.checkOpt()); + node.mHasExp = false; + EXPECT_FALSE(node.checkOpt()); - PoolManager::getInstance().Restore(node); - // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); + PoolManager::getInstance().Restore(node); + // EXPECT_TRUE(PoolManager::getInstance().NoNodeLeak()); } static std::string span; -void capture(const char *msg) -{ - span = msg; -} +void capture(const char *msg) { span = msg; } //./bin/TestCommon --gtest_filter=node.pinpoint_start_traceV1 TEST(node, pinpoint_start_traceV1) { - auto count = usedNode(); - register_span_handler(capture); - NodeID root, child1; - root = pinpoint_start_trace(E_ROOT_NODE); - child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:23", nullptr); - pinpoint_add_clue(child1, "name", "Take1sec", E_LOC_CURRENT); - sleep(1); - pinpoint_end_trace(child1); - - child1 = pinpoint_start_traceV1(root, "TraceOnlyException", nullptr); - pinpoint_add_clue(child1, "name", "Exception", E_LOC_CURRENT); - pinpoint_add_exception(child1, "xxxxxxxxx"); - pinpoint_end_trace(child1); - - child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:2000", nullptr); - pinpoint_add_clue(child1, "name", "TraceMinTimeMs:2000", E_LOC_CURRENT); - sleep(1); - - { - NodeID child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); - pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-1", E_LOC_CURRENT); - pinpoint_end_trace(child); - child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); - pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-2", E_LOC_CURRENT); - pinpoint_end_trace(child); - child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); - pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-3", E_LOC_CURRENT); - pinpoint_end_trace(child); - } - - pinpoint_end_trace(child1); - - child1 = pinpoint_start_traceV1(root, "TraceOnlyException", nullptr); - pinpoint_add_clue(child1, "name", "NoException", E_LOC_CURRENT); - pinpoint_end_trace(child1); - - child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:-23", nullptr); - pinpoint_add_clue(child1, "name", "TraceMinTimeMs:-23", E_LOC_CURRENT); - pinpoint_end_trace(child1); - - pinpoint_end_trace(root); - std::cout << span << std::endl; - EXPECT_TRUE(span.find("Take1sec") != span.npos); - EXPECT_TRUE(span.find("Exception") != span.npos); - EXPECT_TRUE(span.find("TraceMinTimeMs:2000") == span.npos); - EXPECT_TRUE(span.find("NoException") == span.npos); - - EXPECT_TRUE(span.find("childFromTraceMinTimeMs:23-3") == span.npos); - EXPECT_TRUE(span.find("childFromTraceMinTimeMs:23-2") == span.npos); - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); + register_span_handler(capture); + NodeID root, child1; + root = pinpoint_start_trace(E_ROOT_NODE); + child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:23", nullptr); + pinpoint_add_clue(child1, "name", "Take1sec", E_LOC_CURRENT); + sleep(1); + pinpoint_end_trace(child1); + + child1 = pinpoint_start_traceV1(root, "TraceOnlyException", nullptr); + pinpoint_add_clue(child1, "name", "Exception", E_LOC_CURRENT); + pinpoint_add_exception(child1, "xxxxxxxxx"); + pinpoint_end_trace(child1); + + child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:2000", nullptr); + pinpoint_add_clue(child1, "name", "TraceMinTimeMs:2000", E_LOC_CURRENT); + sleep(1); + + { + NodeID child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); + pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-1", E_LOC_CURRENT); + pinpoint_end_trace(child); + child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); + pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-2", E_LOC_CURRENT); + pinpoint_end_trace(child); + child = pinpoint_start_traceV1(child1, "TraceMinTimeMs:23", nullptr); + pinpoint_add_clue(child1, "name", "childFromTraceMinTimeMs:23-3", E_LOC_CURRENT); + pinpoint_end_trace(child); + } + + pinpoint_end_trace(child1); + + child1 = pinpoint_start_traceV1(root, "TraceOnlyException", nullptr); + pinpoint_add_clue(child1, "name", "NoException", E_LOC_CURRENT); + pinpoint_end_trace(child1); + + child1 = pinpoint_start_traceV1(root, "TraceMinTimeMs:-23", nullptr); + pinpoint_add_clue(child1, "name", "TraceMinTimeMs:-23", E_LOC_CURRENT); + pinpoint_end_trace(child1); + + pinpoint_end_trace(root); + std::cout << span << std::endl; + EXPECT_TRUE(span.find("Take1sec") != span.npos); + EXPECT_TRUE(span.find("Exception") != span.npos); + EXPECT_TRUE(span.find("TraceMinTimeMs:2000") == span.npos); + EXPECT_TRUE(span.find("NoException") == span.npos); + + EXPECT_TRUE(span.find("childFromTraceMinTimeMs:23-3") == span.npos); + EXPECT_TRUE(span.find("childFromTraceMinTimeMs:23-2") == span.npos); + EXPECT_EQ(count, usedNode()); } TEST(node, leak_node) { - auto count = PoolManager::getInstance().freeNodesCount(); - NodeID root, child1, child2; - root = pinpoint_start_trace(E_ROOT_NODE); - child1 = pinpoint_start_trace(root); - child2 = pinpoint_start_trace(child1); - // root goes first - pinpoint_end_trace(root); - - pinpoint_end_trace(child1); - pinpoint_end_trace(child2); - - EXPECT_EQ(count, PoolManager::getInstance().freeNodesCount()); - show_status(); + auto count = PoolManager::getInstance().freeNodesCount(); + NodeID root, child1, child2; + root = pinpoint_start_trace(E_ROOT_NODE); + child1 = pinpoint_start_trace(root); + child2 = pinpoint_start_trace(child1); + // root goes first + pinpoint_end_trace(root); + + pinpoint_end_trace(child1); + pinpoint_end_trace(child2); + + EXPECT_EQ(count, PoolManager::getInstance().freeNodesCount()); + show_status(); } TEST(node, tons_of_nodes_01) { - auto count = usedNode(); // PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); - NodeID root = pinpoint_start_trace(E_ROOT_NODE); - for (int i = 0; i < 1000; i++) - { - NodeID child1 = pinpoint_start_trace(root); - pinpoint_end_trace(child1); - } - pinpoint_end_trace(root); - - EXPECT_EQ(count, usedNode()); //); - - count = usedNode(); - root = pinpoint_start_trace(E_ROOT_NODE); - NodeID child1 = root; - for (int i = 0; i < 1000; i++) - { - NodeID child = pinpoint_start_trace(child1); - mark_current_trace_status(root, E_OFFLINE); - pinpoint_end_trace(child); - child1 = child; - } - mark_current_trace_status(root, E_TRACE_BLOCK); - pinpoint_end_trace(root); - - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); // PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); + NodeID root = pinpoint_start_trace(E_ROOT_NODE); + for (int i = 0; i < 1000; i++) { + NodeID child1 = pinpoint_start_trace(root); + pinpoint_end_trace(child1); + } + pinpoint_end_trace(root); + + EXPECT_EQ(count, usedNode()); //); + + count = usedNode(); + root = pinpoint_start_trace(E_ROOT_NODE); + NodeID child1 = root; + for (int i = 0; i < 1000; i++) { + NodeID child = pinpoint_start_trace(child1); + mark_current_trace_status(root, E_OFFLINE); + pinpoint_end_trace(child); + child1 = child; + } + mark_current_trace_status(root, E_TRACE_BLOCK); + pinpoint_end_trace(root); + + EXPECT_EQ(count, usedNode()); } TEST(node, tons_of_nodes_2k) { - auto count = usedNode(); // PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); - NodeID root = pinpoint_start_trace(E_ROOT_NODE); - NodeID next = root; - for (int i = 0; i < 2000; i++) - { - NodeID child = pinpoint_start_trace(next); - pinpoint_end_trace(child); - if (i % 2 == 0) - { - next = child; - } - } - pinpoint_end_trace(root); - - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); // PoolManager::getInstance().totoalNodesCount() - PoolManager::getInstance().freeNodesCount(); + NodeID root = pinpoint_start_trace(E_ROOT_NODE); + NodeID next = root; + for (int i = 0; i < 2000; i++) { + NodeID child = pinpoint_start_trace(next); + pinpoint_end_trace(child); + if (i % 2 == 0) { next = child; } + } + pinpoint_end_trace(root); + + EXPECT_EQ(count, usedNode()); } TEST(node, tons_of_nodes_leak) { - auto count = usedNode(); + auto count = usedNode(); - NodeID root, child_1, child_2; - root = pinpoint_start_trace(E_ROOT_NODE); + NodeID root, child_1, child_2; + root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - child_2 = pinpoint_start_trace(child_1); + child_1 = pinpoint_start_trace(root); + child_2 = pinpoint_start_trace(child_1); - pinpoint_end_trace(child_2); + pinpoint_end_trace(child_2); - pinpoint_end_trace(root); - pinpoint_end_trace(child_1); - EXPECT_EQ(count, usedNode()); + pinpoint_end_trace(root); + pinpoint_end_trace(child_1); + EXPECT_EQ(count, usedNode()); } TEST(node, tons_of_nodes_free_all) { - auto count = usedNode(); + auto count = usedNode(); - NodeID root, child_1, child_2; - root = pinpoint_start_trace(E_ROOT_NODE); + NodeID root, child_1, child_2; + root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - child_2 = pinpoint_start_trace(child_1); - freeNodeTree(root); - pinpoint_end_trace(child_2); + child_1 = pinpoint_start_trace(root); + child_2 = pinpoint_start_trace(child_1); + freeNodeTree(root); + pinpoint_end_trace(child_2); - pinpoint_end_trace(root); - pinpoint_end_trace(child_1); - EXPECT_EQ(count, usedNode()); + pinpoint_end_trace(root); + pinpoint_end_trace(child_1); + EXPECT_EQ(count, usedNode()); } //./bin/TestCommon --gtest_filter=node.free_when_add TEST(node, free_when_add) { - auto count = usedNode(); - NodeID root; - auto make_it_busy = [&]() - { - auto w_root = PoolManager::getInstance().GetWrapperNode(); - root = w_root->mPoolIndex; - auto w_child = PoolManager::getInstance().GetWrapperNode(); - w_root->addChild(w_child); - w_child->AddTraceDetail("E_ROOT_NODE", 234); - std::this_thread::sleep_for(std::chrono::seconds(2)); - }; - std::thread t(make_it_busy); - std::this_thread::sleep_for(std::chrono::seconds(1)); - auto start = Helper::get_current_msec_stamp(); - freeNodeTree(root); - freeNodeTree(E_INVALID_NODE); - freeNodeTree(E_ROOT_NODE); - auto end = Helper::get_current_msec_stamp() - start; - printf("it takes: %ld to free ", end); - t.join(); - EXPECT_EQ(count, usedNode()); - EXPECT_TRUE(end >= 100); + auto count = usedNode(); + NodeID root; + auto make_it_busy = [&]() { + auto w_root = PoolManager::getInstance().GetWrapperNode(); + root = w_root->mPoolIndex; + auto w_child = PoolManager::getInstance().GetWrapperNode(); + w_root->addChild(w_child); + w_child->AddTraceDetail("E_ROOT_NODE", 234); + std::this_thread::sleep_for(std::chrono::seconds(2)); + }; + std::thread t(make_it_busy); + std::this_thread::sleep_for(std::chrono::seconds(1)); + auto start = Helper::get_current_msec_stamp(); + freeNodeTree(root); + freeNodeTree(E_INVALID_NODE); + freeNodeTree(E_ROOT_NODE); + auto end = Helper::get_current_msec_stamp() - start; + printf("it takes: %ld to free ", end); + t.join(); + EXPECT_EQ(count, usedNode()); + EXPECT_TRUE(end >= 100); } //./bin/TestCommon --gtest_filter=node.orphan_node TEST(node, orphan_node) { - auto count = usedNode(); - NodeID root, child_1, orphan; - root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - orphan = pinpoint_start_trace(child_1); - pinpoint_end_trace(child_1); - pinpoint_end_trace(root); - - root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(E_ROOT_NODE); - debug_nodeid(orphan); - pinpoint_end_trace(orphan); - debug_nodeid(orphan); - pinpoint_end_trace(child_1); - pinpoint_end_trace(root); - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); + NodeID root, child_1, orphan; + root = pinpoint_start_trace(E_ROOT_NODE); + child_1 = pinpoint_start_trace(root); + orphan = pinpoint_start_trace(child_1); + pinpoint_end_trace(child_1); + pinpoint_end_trace(root); + + root = pinpoint_start_trace(E_ROOT_NODE); + child_1 = pinpoint_start_trace(E_ROOT_NODE); + debug_nodeid(orphan); + pinpoint_end_trace(orphan); + debug_nodeid(orphan); + pinpoint_end_trace(child_1); + pinpoint_end_trace(root); + EXPECT_EQ(count, usedNode()); } //./bin/TestCommon --gtest_filter=node.orphan_node_01 TEST(node, orphan_node_01) { - auto count = usedNode(); - NodeID root, child_1, orphan; - root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - pinpoint_end_trace(root); - orphan = pinpoint_start_trace(child_1); + auto count = usedNode(); + NodeID root, child_1, orphan; + root = pinpoint_start_trace(E_ROOT_NODE); + child_1 = pinpoint_start_trace(root); + pinpoint_end_trace(root); + orphan = pinpoint_start_trace(child_1); - pinpoint_end_trace(child_1); - pinpoint_end_trace(orphan); + pinpoint_end_trace(child_1); + pinpoint_end_trace(orphan); - EXPECT_EQ(count, usedNode()); + EXPECT_EQ(count, usedNode()); } //./bin/TestCommon --gtest_filter=node.orphan_root_parent_end TEST(node, orphan_parent_root_end) { - auto count = usedNode(); - NodeID root, child_1, orphan; - root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - orphan = pinpoint_start_trace(child_1); - pinpoint_end_trace(child_1); - pinpoint_end_trace(root); + auto count = usedNode(); + NodeID root, child_1, orphan; + root = pinpoint_start_trace(E_ROOT_NODE); + child_1 = pinpoint_start_trace(root); + orphan = pinpoint_start_trace(child_1); + pinpoint_end_trace(child_1); + pinpoint_end_trace(root); - pinpoint_end_trace(orphan); + pinpoint_end_trace(orphan); - EXPECT_EQ(count, usedNode()); + EXPECT_EQ(count, usedNode()); } TEST(node, orphan_root_parent_end) { - auto count = usedNode(); - NodeID root, child_1, orphan; - root = pinpoint_start_trace(E_ROOT_NODE); - child_1 = pinpoint_start_trace(root); - orphan = pinpoint_start_trace(child_1); - pinpoint_end_trace(root); - pinpoint_end_trace(child_1); + auto count = usedNode(); + NodeID root, child_1, orphan; + root = pinpoint_start_trace(E_ROOT_NODE); + child_1 = pinpoint_start_trace(root); + orphan = pinpoint_start_trace(child_1); + pinpoint_end_trace(root); + pinpoint_end_trace(child_1); - pinpoint_end_trace(orphan); + pinpoint_end_trace(orphan); - EXPECT_EQ(count, usedNode()); + EXPECT_EQ(count, usedNode()); } // ./bin/TestCommon --gtest_filter=node.end_trace_in_mt TEST(node, end_trace_in_mt) { - auto count = usedNode(); - NodeID root = pinpoint_start_trace(E_ROOT_NODE); - NodeID next = root; - // limit size 100; due to https://github.com/pinpoint-apm/pinpoint-c-agent/runs/6806024797?check_suite_focus=true bus error under macos - for (int i = 0; i < 100; i++) - { - next = pinpoint_start_trace(next); - pinpoint_end_trace(next); - } - - std::mutex mtx; - std::condition_variable cv; - - auto thread_func = [&]() - { - std::unique_lock lck(mtx); - cv.wait(lck); - pp_trace("%lu ", std::this_thread::get_id()); - pinpoint_end_trace(root); - }; - std::vector threads; - for (int i = 0; i < 10; i++) - { - // std::thread t(thread_func); - threads.emplace_back(thread_func); - } - // wait for all threads running - sleep(2); - cv.notify_all(); - for (auto &thread : threads) - thread.join(); - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); + NodeID root = pinpoint_start_trace(E_ROOT_NODE); + NodeID next = root; + // limit size 100; due to https://github.com/pinpoint-apm/pinpoint-c-agent/runs/6806024797?check_suite_focus=true bus error under macos + for (int i = 0; i < 100; i++) { + next = pinpoint_start_trace(next); + pinpoint_end_trace(next); + } + + std::mutex mtx; + std::condition_variable cv; + + auto thread_func = [&]() { + std::unique_lock lck(mtx); + cv.wait(lck); + pp_trace("%lu ", std::this_thread::get_id()); + pinpoint_end_trace(root); + }; + std::vector threads; + for (int i = 0; i < 10; i++) { + // std::thread t(thread_func); + threads.emplace_back(thread_func); + } + // wait for all threads running + sleep(2); + cv.notify_all(); + for (auto &thread : threads) thread.join(); + EXPECT_EQ(count, usedNode()); } // ./bin/TestCommon --gtest_filter=node.max_sub_nodes TEST(node, max_sub_nodes) { - auto count = usedNode(); - NodeID root = pinpoint_start_trace(E_ROOT_NODE); - while (true) - { - NodeID next = pinpoint_start_trace(root); - if (next == E_INVALID_NODE) - { - break; - } - pinpoint_end_trace(next); - } - pinpoint_end_trace(root); - EXPECT_EQ(count, usedNode()); + auto count = usedNode(); + NodeID root = pinpoint_start_trace(E_ROOT_NODE); + while (true) { + NodeID next = pinpoint_start_trace(root); + if (next == E_INVALID_NODE) { break; } + pinpoint_end_trace(next); + } + pinpoint_end_trace(root); + EXPECT_EQ(count, usedNode()); } \ No newline at end of file diff --git a/common/test/test_node_pool.cc b/common/test/test_node_pool.cc index c248cf0ce..8229eef46 100644 --- a/common/test/test_node_pool.cc +++ b/common/test/test_node_pool.cc @@ -8,57 +8,55 @@ using NodePool::TraceNode; TEST(poolManger, get_and_give_back) { - NodePool::PoolManager pool; - // new - TraceNode &_node = pool.Take(); - void *p = &_node; - NodeID id = _node.getId(); - NodeID child, next; - // give back - pool.Restore(id, child, next); - EXPECT_EQ(child, E_INVALID_NODE); - EXPECT_EQ(next, E_INVALID_NODE); - TraceNode &_node_01 = pool.Take(); + NodePool::PoolManager pool; + // new + TraceNode &_node = pool.Take(); + void *p = &_node; + NodeID id = _node.getId(); + NodeID child, next; + // give back + pool.Restore(id, child, next); + EXPECT_EQ(child, E_INVALID_NODE); + EXPECT_EQ(next, E_INVALID_NODE); + TraceNode &_node_01 = pool.Take(); - // ref current - TraceNode &ref_new_node = pool.Take(_node_01.getId()); + // ref current + TraceNode &ref_new_node = pool.Take(_node_01.getId()); - EXPECT_EQ(p, &_node); - EXPECT_EQ(ref_new_node, _node); - // reuse the same id - EXPECT_EQ(id, _node.getId()); - EXPECT_THROW(pool.Take(NodeID(100)), std::out_of_range); - EXPECT_THROW(pool.Take(NodeID(10000)), std::out_of_range); + EXPECT_EQ(p, &_node); + EXPECT_EQ(ref_new_node, _node); + // reuse the same id + EXPECT_EQ(id, _node.getId()); + EXPECT_THROW(pool.Take(NodeID(100)), std::out_of_range); + EXPECT_THROW(pool.Take(NodeID(10000)), std::out_of_range); } static NodePool::PoolManager g_pool; void test_node_pool(bool &result) { - NodeID it = E_INVALID_NODE; - for (int i = 0; i < 1000; i++) - { - TraceNode &_node = g_pool.Take(); - usleep(1000); - if (_node.getId() == it) - { - result = false; - return; - } - g_pool.Restore(_node); - // g_pool.freeNode(_node.getId()); + NodeID it = E_INVALID_NODE; + for (int i = 0; i < 1000; i++) { + TraceNode &_node = g_pool.Take(); + usleep(1000); + if (_node.getId() == it) { + result = false; + return; } - result = true; + g_pool.Restore(_node); + // g_pool.freeNode(_node.getId()); + } + result = true; } TEST(poolManger, get_and_give_back_tls) { - bool rth1, rth2; - std::thread t1(test_node_pool, std::ref(rth1)); - std::thread t2(test_node_pool, std::ref(rth2)); + bool rth1, rth2; + std::thread t1(test_node_pool, std::ref(rth1)); + std::thread t2(test_node_pool, std::ref(rth2)); - t1.join(); - t2.join(); - EXPECT_TRUE(rth1); - EXPECT_TRUE(rth2); + t1.join(); + t2.join(); + EXPECT_TRUE(rth1); + EXPECT_TRUE(rth2); } diff --git a/common/test/test_trans_layer.cc b/common/test/test_trans_layer.cc index 6bb088f29..60da29cc9 100644 --- a/common/test/test_trans_layer.cc +++ b/common/test/test_trans_layer.cc @@ -21,123 +21,118 @@ bool run = true; void sig_exit(int signm) { - (void)signm; - run = false; + (void) signm; + run = false; } int fack_server() { - int fd = socket(AF_UNIX, SOCK_STREAM, 0); - struct sockaddr_un address = {0, {0}}; - address.sun_family = AF_UNIX; - strncpy(address.sun_path, unix_socket, sizeof(address.sun_path) - 1); - remove(unix_socket); - if (bind(fd, (struct sockaddr *)&address, sizeof(address)) == -1) - { - pp_trace("bind server socket failed:%s", strerror(errno)); - return 0; - } - listen(fd, 10); - char buffer[1024] = {0}; - struct sockaddr addr; - socklen_t addrlen; - int cfd = accept(fd, &addr, &addrlen); - assert(cfd != -1); - pp_trace("recv cfd:%d", cfd); - Json::Value agentInfo; - - agentInfo["time"] = 1234567; - agentInfo["id"] = "test-app"; - agentInfo["name"] = "test-name"; - - Json::FastWriter writer; - std::string msg = writer.write(agentInfo); - strcpy((char *)buffer + sizeof(Header), msg.c_str()); - - int len = msg.length(); - Header *header = (Header *)buffer; - header->type = htonl(RESPONSE_AGENT_INFO); - header->length = htonl(len); - int ret = send(cfd, buffer, len + sizeof(*header), 0); - pp_trace("send[%d] [%d] %s ", cfd, ret, strerror(errno)); - recv(cfd, buffer, 1024, 0); - close(cfd); + int fd = socket(AF_UNIX, SOCK_STREAM, 0); + struct sockaddr_un address = {0, {0}}; + address.sun_family = AF_UNIX; + strncpy(address.sun_path, unix_socket, sizeof(address.sun_path) - 1); + remove(unix_socket); + if (bind(fd, (struct sockaddr *) &address, sizeof(address)) == -1) { + pp_trace("bind server socket failed:%s", strerror(errno)); return 0; + } + listen(fd, 10); + char buffer[1024] = {0}; + struct sockaddr addr; + socklen_t addrlen; + int cfd = accept(fd, &addr, &addrlen); + assert(cfd != -1); + pp_trace("recv cfd:%d", cfd); + Json::Value agentInfo; + + agentInfo["time"] = 1234567; + agentInfo["id"] = "test-app"; + agentInfo["name"] = "test-name"; + + Json::FastWriter writer; + std::string msg = writer.write(agentInfo); + strcpy((char *) buffer + sizeof(Header), msg.c_str()); + + int len = msg.length(); + Header *header = (Header *) buffer; + header->type = htonl(RESPONSE_AGENT_INFO); + header->length = htonl(len); + int ret = send(cfd, buffer, len + sizeof(*header), 0); + pp_trace("send[%d] [%d] %s ", cfd, ret, strerror(errno)); + recv(cfd, buffer, 1024, 0); + close(cfd); + return 0; } void handle_agent_info(int type, const char *buf, size_t len) { - printf("%s", buf); - EXPECT_EQ(type, RESPONSE_AGENT_INFO); - Json::Value root; - Json::Reader reader; - reader.parse(buf, buf + len, root); - EXPECT_EQ(root["time"].asInt64(), 1234567); - EXPECT_STREQ(root["id"].asCString(), "test-app"); - EXPECT_STREQ(root["name"].asCString(), "test-name"); - run = false; + printf("%s", buf); + EXPECT_EQ(type, RESPONSE_AGENT_INFO); + Json::Value root; + Json::Reader reader; + reader.parse(buf, buf + len, root); + EXPECT_EQ(root["time"].asInt64(), 1234567); + EXPECT_STREQ(root["id"].asCString(), "test-app"); + EXPECT_STREQ(root["name"].asCString(), "test-name"); + run = false; } TEST(translayer, unix_socket_layer) { - pid_t pid = fork(); - if (pid == 0) - { - fack_server(); - exit(0); - } - sleep(3); - std::string remote = global_agent_info.co_host; - TransLayer layer(remote); - using namespace std::placeholders; - layer.registerPeerMsgCallback(std::bind(handle_agent_info, _1, _2, _3), NULL); - while (run) - { - layer.trans_layer_pool(300); - } - std::string data = "msg-1918"; - layer.copy_into_send_buffer(data); - layer.forceFlushMsg(10); - waitpid(pid, 0, 0); + pid_t pid = fork(); + if (pid == 0) { + fack_server(); + exit(0); + } + sleep(3); + std::string remote = global_agent_info.co_host; + TransLayer layer(remote); + using namespace std::placeholders; + layer.registerPeerMsgCallback(std::bind(handle_agent_info, _1, _2, _3), NULL); + while (run) { layer.trans_layer_pool(300); } + std::string data = "msg-1918"; + layer.copy_into_send_buffer(data); + layer.forceFlushMsg(10); + waitpid(pid, 0, 0); } TEST(translayer, stream_socket_layer) { - int fd = -1; - fd = TransLayer::connect_stream_remote("www.naver.com:80"); - EXPECT_GT(fd, 2); - close(fd); + int fd = -1; + fd = TransLayer::connect_stream_remote("www.naver.com:80"); + EXPECT_GT(fd, 2); + close(fd); - fd = TransLayer::connect_stream_remote("172.217.175.68:80"); - EXPECT_GT(fd, 2); - close(fd); + fd = TransLayer::connect_stream_remote("172.217.175.68:80"); + EXPECT_GT(fd, 2); + close(fd); - fd = TransLayer::connect_stream_remote("-.217.175.68:80"); - EXPECT_EQ(fd, -1); + fd = TransLayer::connect_stream_remote("-.217.175.68:80"); + EXPECT_EQ(fd, -1); - fd = TransLayer::connect_stream_remote("-.217.175.68:-80"); - EXPECT_EQ(fd, -1); + fd = TransLayer::connect_stream_remote("-.217.175.68:-80"); + EXPECT_EQ(fd, -1); - fd = TransLayer::connect_stream_remote("-.217.175.68"); - EXPECT_EQ(fd, -1); + fd = TransLayer::connect_stream_remote("-.217.175.68"); + EXPECT_EQ(fd, -1); - fd = TransLayer::connect_stream_remote(":90"); - EXPECT_EQ(fd, -1); + fd = TransLayer::connect_stream_remote(":90"); + EXPECT_EQ(fd, -1); } TEST(ConnectionPool, API) { - std::string remote = global_agent_info.co_host; - SpanConnectionPool _pool(remote.c_str()); + std::string remote = global_agent_info.co_host; + SpanConnectionPool _pool(remote.c_str()); - // SpanConnectionPool _pool1 = _pool; - // (void)_pool1; + // SpanConnectionPool _pool1 = _pool; + // (void)_pool1; - TransConnection _conn = _pool.get(); + TransConnection _conn = _pool.get(); - EXPECT_EQ(_conn->connect_stream_remote("-.217.175.68:-80"), -1); + EXPECT_EQ(_conn->connect_stream_remote("-.217.175.68:-80"), -1); - _pool.free(_conn); + _pool.free(_conn); } #pragma GCC diagnostic pop \ No newline at end of file diff --git a/common/test/test_util.cc b/common/test/test_util.cc index a2f0176c7..a1d6767f1 100644 --- a/common/test/test_util.cc +++ b/common/test/test_util.cc @@ -35,136 +35,129 @@ using NodePool::PoolManager; using NodePool::TraceNode; TEST(util, sst) { - ADDTRACE(); + ADDTRACE(); - std::this_thread::sleep_for(seconds(1)); + std::this_thread::sleep_for(seconds(1)); } TEST(util, onOFFline) { - SafeSharedState &_state = SafeSharedState::instance(); - EXPECT_FALSE(_state.isReady()); - _state.updateStartTime(1316615272); - // EXPECT_EQ(1316615272, _state.getStartTime()); - EXPECT_TRUE(_state.isReady()); + SafeSharedState &_state = SafeSharedState::instance(); + EXPECT_FALSE(_state.isReady()); + _state.updateStartTime(1316615272); + // EXPECT_EQ(1316615272, _state.getStartTime()); + EXPECT_TRUE(_state.isReady()); } TEST(util, time_in_msec) { - uint64_t time = Helper::get_current_msec_stamp(); - std::this_thread::sleep_for(seconds(1)); - EXPECT_GE(Helper::get_current_msec_stamp(), time + 1000); + uint64_t time = Helper::get_current_msec_stamp(); + std::this_thread::sleep_for(seconds(1)); + EXPECT_GE(Helper::get_current_msec_stamp(), time + 1000); } // restrict typeva_start TEST(util, test_node_to_string) { - Json::Value _value; + Json::Value _value; - _value["a"] = 1; - _value["b"] = 1; - _value["d"] = 1; + _value["a"] = 1; + _value["b"] = 1; + _value["d"] = 1; - std::string str = Helper::node_tree_to_string(_value); - EXPECT_STREQ(str.c_str(), "{\"a\":1,\"b\":1,\"d\":1}"); + std::string str = Helper::node_tree_to_string(_value); + EXPECT_STREQ(str.c_str(), "{\"a\":1,\"b\":1,\"d\":1}"); } int sum(int n_args, ...) { - va_list ap; - va_start(ap, n_args); - int var = n_args; + va_list ap; + va_start(ap, n_args); + int var = n_args; - int total = n_args; - do - { - var = va_arg(ap, int); - total += var; - } while (var != 0); + int total = n_args; + do { + var = va_arg(ap, int); + total += var; + } while (var != 0); - va_end(ap); + va_end(ap); - return total; + return total; } //./bin/unittest --gtest_filter=util.variadic_func TEST(util, variadic_func_int) { - EXPECT_EQ(sum(1, 2, 3, 4, 5, 6, 0), 21); - EXPECT_EQ(sum(1, 2, 3, 5, 0), 11); + EXPECT_EQ(sum(1, 2, 3, 4, 5, 6, 0), 21); + EXPECT_EQ(sum(1, 2, 3, 5, 0), 11); } int opt(const char *start, ...) { - va_list ap; - va_start(ap, start); - const char *var = start; + va_list ap; + va_start(ap, start); + const char *var = start; - int total = 0; - while (var != nullptr) - { - printf("%s\n", var); - total++; - var = va_arg(ap, const char *); - } + int total = 0; + while (var != nullptr) { + printf("%s\n", var); + total++; + var = va_arg(ap, const char *); + } - va_end(ap); + va_end(ap); - return total; + return total; } //./bin/unittest --gtest_filter=util.variadic_func_str TEST(util, variadic_func_str) { - EXPECT_EQ(opt("a", "b", "c", "d", nullptr), 4); - EXPECT_EQ(opt("a", "b", "c", nullptr), 3); + EXPECT_EQ(opt("a", "b", "c", "d", nullptr), 4); + EXPECT_EQ(opt("a", "b", "c", nullptr), 3); } TEST(util, mergeTraceNodeTree) { - TraceNode &n1 = PoolManager::getInstance().Take(); - TraceNode &n2 = PoolManager::getInstance().Take(); - TraceNode &n3 = PoolManager::getInstance().Take(); - TraceNode &n4 = PoolManager::getInstance().Take(); - - n2.mParentId = n1.mPoolIndex; - n1.mChildHeadId = n2.mPoolIndex; - n3.mParentId = n2.mPoolIndex; - n4.mParentId = n2.mPoolIndex; - n3.mNextId = n4.mPoolIndex; - n2.mChildHeadId = n3.mPoolIndex; - - Json::Value var = Helper::mergeTraceNodeTree(n1); - std::cout << var.toStyledString(); + TraceNode &n1 = PoolManager::getInstance().Take(); + TraceNode &n2 = PoolManager::getInstance().Take(); + TraceNode &n3 = PoolManager::getInstance().Take(); + TraceNode &n4 = PoolManager::getInstance().Take(); + + n2.mParentId = n1.mPoolIndex; + n1.mChildHeadId = n2.mPoolIndex; + n3.mParentId = n2.mPoolIndex; + n4.mParentId = n2.mPoolIndex; + n3.mNextId = n4.mPoolIndex; + n2.mChildHeadId = n3.mPoolIndex; + + Json::Value var = Helper::mergeTraceNodeTree(n1); + std::cout << var.toStyledString(); } std::string span; -void captureSpan(const char *s) -{ - span = s; -} +void captureSpan(const char *s) { span = s; } TEST(util, mergeTraceNodeTree_1) { - - register_span_handler(captureSpan); - - NodeID id1, - id2, id3, id4; - Json::Value var; - id1 = pinpoint_start_trace(E_ROOT_NODE); - pinpoint_add_clue(id1, "name", "id1", E_LOC_CURRENT); - id2 = pinpoint_start_trace(id1); - pinpoint_add_clue(id2, "name", "id2", E_LOC_CURRENT); - id3 = pinpoint_start_trace(id2); - pinpoint_add_clue(id3, "name", "id3", E_LOC_CURRENT); - id4 = pinpoint_start_trace(id2); - pinpoint_add_clue(id4, "name", "id4", E_LOC_CURRENT); - pinpoint_end_trace(id3); - pinpoint_end_trace(id2); - pinpoint_end_trace(id1); - pinpoint_end_trace(id4); - EXPECT_TRUE(span.find("id4") != span.npos); - EXPECT_TRUE(span.find("id1") != span.npos); - EXPECT_TRUE(span.find("id2") != span.npos); - EXPECT_TRUE(span.find("id3") != span.npos); - EXPECT_TRUE(span.find("calls") != span.npos); + register_span_handler(captureSpan); + + NodeID id1, id2, id3, id4; + Json::Value var; + id1 = pinpoint_start_trace(E_ROOT_NODE); + pinpoint_add_clue(id1, "name", "id1", E_LOC_CURRENT); + id2 = pinpoint_start_trace(id1); + pinpoint_add_clue(id2, "name", "id2", E_LOC_CURRENT); + id3 = pinpoint_start_trace(id2); + pinpoint_add_clue(id3, "name", "id3", E_LOC_CURRENT); + id4 = pinpoint_start_trace(id2); + pinpoint_add_clue(id4, "name", "id4", E_LOC_CURRENT); + pinpoint_end_trace(id3); + pinpoint_end_trace(id2); + pinpoint_end_trace(id1); + pinpoint_end_trace(id4); + EXPECT_TRUE(span.find("id4") != span.npos); + EXPECT_TRUE(span.find("id1") != span.npos); + EXPECT_TRUE(span.find("id2") != span.npos); + EXPECT_TRUE(span.find("id3") != span.npos); + EXPECT_TRUE(span.find("calls") != span.npos); } diff --git a/src/PHP/pinpoint_php.cpp b/src/PHP/pinpoint_php.cpp index c3ea49aba..d4fe9dda3 100644 --- a/src/PHP/pinpoint_php.cpp +++ b/src/PHP/pinpoint_php.cpp @@ -39,11 +39,11 @@ #include "php.h" #include "php_ini.h" -//#include "php_var.h" +// #include "php_var.h" #include "ext/standard/info.h" -#include "php_pinpoint_php.h" #include "common.h" +#include "php_pinpoint_php.h" #include #ifdef COMPILE_DL_PINPOINT_PHP @@ -79,20 +79,16 @@ static void pinpoint_log(char *msg); PHP_INI_BEGIN() -STD_PHP_INI_ENTRY("pinpoint_php.SendSpanTimeOutMs", "0", PHP_INI_ALL, - OnUpdateLong, w_timeout_ms, zend_pinpoint_php_globals, pinpoint_php_globals) +STD_PHP_INI_ENTRY("pinpoint_php.SendSpanTimeOutMs", "0", PHP_INI_ALL, OnUpdateLong, w_timeout_ms, zend_pinpoint_php_globals, pinpoint_php_globals) -STD_PHP_INI_ENTRY("pinpoint_php.CollectorHost", "unix:/tmp/collector.sock", PHP_INI_ALL, - OnUpdateString, co_host, zend_pinpoint_php_globals, pinpoint_php_globals) +STD_PHP_INI_ENTRY("pinpoint_php.CollectorHost", "unix:/tmp/collector.sock", PHP_INI_ALL, OnUpdateString, co_host, zend_pinpoint_php_globals, + pinpoint_php_globals) -STD_PHP_INI_ENTRY("pinpoint_php.UnitTest", "no", PHP_INI_ALL, - OnUpdateBool, utest_flag, zend_pinpoint_php_globals, pinpoint_php_globals) +STD_PHP_INI_ENTRY("pinpoint_php.UnitTest", "no", PHP_INI_ALL, OnUpdateBool, utest_flag, zend_pinpoint_php_globals, pinpoint_php_globals) -STD_PHP_INI_ENTRY("pinpoint_php.TraceLimit", "-1", PHP_INI_ALL, - OnUpdateLong, tracelimit, zend_pinpoint_php_globals, pinpoint_php_globals) +STD_PHP_INI_ENTRY("pinpoint_php.TraceLimit", "-1", PHP_INI_ALL, OnUpdateLong, tracelimit, zend_pinpoint_php_globals, pinpoint_php_globals) -STD_PHP_INI_ENTRY("pinpoint_php.DebugReport", "no", PHP_INI_ALL, - OnUpdateBool, debug_report, zend_pinpoint_php_globals, pinpoint_php_globals) +STD_PHP_INI_ENTRY("pinpoint_php.DebugReport", "no", PHP_INI_ALL, OnUpdateBool, debug_report, zend_pinpoint_php_globals, pinpoint_php_globals) PHP_INI_END() @@ -139,19 +135,13 @@ ZEND_END_ARG_INFO() * Every user visible function must have an entry in pinpioint_php_functions[]. */ const zend_function_entry pinpoint_php_functions[] = { - PHP_FE(pinpoint_start_trace, arginfo_add_id) - PHP_FE(pinpoint_end_trace, arginfo_add_id) - PHP_FE(pinpoint_unique_id, arginfo_none) - PHP_FE(pinpoint_get_func_ref_args, arginfo_none) - PHP_FE(pinpoint_drop_trace, arginfo_add_id) - PHP_FE(pinpoint_start_time, arginfo_none) - PHP_FE(pinpoint_set_context, arginfo_add_id_key_value) - PHP_FE(pinpoint_get_context, arginfo_add_id_value) - PHP_FE(pinpoint_tracelimit, arginfo_add_timestamp) - PHP_FE(pinpoint_mark_as_error, arginfo_add_msg_filename_lineno_id) - PHP_FE(pinpoint_add_clue, arginfo_add_id_key_value_flag) - PHP_FE(pinpoint_add_clues, arginfo_add_id_key_value_flag) - PHP_FE_END /* Must be the last line in pinpioint_php_functions[] */ + PHP_FE(pinpoint_start_trace, arginfo_add_id) PHP_FE(pinpoint_end_trace, arginfo_add_id) PHP_FE(pinpoint_unique_id, arginfo_none) + PHP_FE(pinpoint_get_func_ref_args, arginfo_none) PHP_FE(pinpoint_drop_trace, arginfo_add_id) PHP_FE(pinpoint_start_time, arginfo_none) + PHP_FE(pinpoint_set_context, arginfo_add_id_key_value) PHP_FE(pinpoint_get_context, arginfo_add_id_value) + PHP_FE(pinpoint_tracelimit, arginfo_add_timestamp) PHP_FE(pinpoint_mark_as_error, arginfo_add_msg_filename_lineno_id) + PHP_FE(pinpoint_add_clue, arginfo_add_id_key_value_flag) PHP_FE(pinpoint_add_clues, arginfo_add_id_key_value_flag) + PHP_FE_END /* Must be the last line in + pinpioint_php_functions[] */ }; /* }}} */ @@ -159,19 +149,18 @@ const zend_function_entry pinpoint_php_functions[] = { */ zend_module_entry pinpoint_php_module_entry = { #if ZEND_MODULE_API_NO >= 20010901 - STANDARD_MODULE_HEADER, + STANDARD_MODULE_HEADER, #endif - "pinpoint_php", - pinpoint_php_functions, - PHP_MINIT(pinpoint_php), - PHP_MSHUTDOWN(pinpoint_php), - PHP_RINIT(pinpoint_php), /* Replace with NULL if there's nothing to do at request start */ - PHP_RSHUTDOWN(pinpoint_php), /* Replace with NULL if there's nothing to do at request end */ - PHP_MINFO(pinpoint_php), + "pinpoint_php", pinpoint_php_functions, PHP_MINIT(pinpoint_php), PHP_MSHUTDOWN(pinpoint_php), + PHP_RINIT(pinpoint_php), /* Replace with NULL if there's nothing to do at + request start */ + PHP_RSHUTDOWN(pinpoint_php), /* Replace with NULL if there's nothing to do + at request end */ + PHP_MINFO(pinpoint_php), #if ZEND_MODULE_API_NO >= 20010901 - PHP_PINPOINT_PHP_VERSION, + PHP_PINPOINT_PHP_VERSION, #endif - STANDARD_MODULE_PROPERTIES}; + STANDARD_MODULE_PROPERTIES}; /* }}} */ #if PHP_VERSION_ID >= 80100 void (*old_error_cb)(int type, zend_string *error_filename, const uint32_t error_lineno, zend_string *message); @@ -182,332 +171,291 @@ void (*old_error_cb)(int type, const char *error_filename, const uint error_line #endif #define safe_free(x) \ - if ((x)) \ - { \ - free((x)); \ - (x) = NULL; \ - } + if ((x)) { \ + free((x)); \ + (x) = NULL; \ + } PHP_FUNCTION(pinpoint_drop_trace) { - long _id = -1; - NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; + long _id = -1; + NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; #if PHP_VERSION_ID < 70000 - zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); #else - zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); #endif - if (_id == -1) - { - id = pinpoint_get_per_thread_id(); - } - else - { - id = (NodeID)_id; - } - mark_current_trace_status(id, E_TRACE_BLOCK); - RETURN_TRUE; + if (_id == -1) { + id = pinpoint_get_per_thread_id(); + } else { + id = (NodeID) _id; + } + mark_current_trace_status(id, E_TRACE_BLOCK); + RETURN_TRUE; } PHP_FUNCTION(pinpoint_set_context) { - long _id = -1; - std::string key; - zval *zvalue; + long _id = -1; + std::string key; + zval *zvalue; #if PHP_VERSION_ID < 70000 - char *zkey = NULL; - int zkey_len; + char *zkey = NULL; + int zkey_len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &zkey, &zkey_len, &zvalue, &_id) == FAILURE) - { - zend_error(E_ERROR, "key/value required"); - return; - } - key = std::string(zkey, zkey_len); + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &zkey, &zkey_len, &zvalue, &_id) == FAILURE) { + zend_error(E_ERROR, "key/value required"); + return; + } + key = std::string(zkey, zkey_len); #else - zend_string *zkey; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz|l", &zkey, &zvalue, &_id) == FAILURE) - { - zend_error(E_ERROR, "key/value required"); - return; - } - key = std::string(zkey->val, zkey->len); + zend_string *zkey; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "Sz|l", &zkey, &zvalue, &_id) == FAILURE) { + zend_error(E_ERROR, "key/value required"); + return; + } + key = std::string(zkey->val, zkey->len); #endif - if (_id == -1) - { - _id = pinpoint_get_per_thread_id(); - ; - } - - switch (Z_TYPE_P(zvalue)) - { - // case IS_LONG: - // pinpoint_set_context_long(_id,key.c_str(),Z_LVAL_P(zvalue)); - // break; - case IS_STRING: - { - std::string value(Z_STRVAL_P(zvalue), Z_STRLEN_P(zvalue)); - pinpoint_set_context_key((NodeID)_id, key.c_str(), value.c_str()); - } - break; + if (_id == -1) { + _id = pinpoint_get_per_thread_id(); + ; + } + + switch (Z_TYPE_P(zvalue)) { + // case IS_LONG: + // pinpoint_set_context_long(_id,key.c_str(),Z_LVAL_P(zvalue)); + // break; + case IS_STRING: { + std::string value(Z_STRVAL_P(zvalue), Z_STRLEN_P(zvalue)); + pinpoint_set_context_key((NodeID) _id, key.c_str(), value.c_str()); + } break; default: - zend_error(E_WARNING, "value only support string"); - return; - } - RETURN_TRUE; + zend_error(E_WARNING, "value only support string"); + return; + } + RETURN_TRUE; } PHP_FUNCTION(pinpoint_get_context) { - long _id = -1; - std::string key; + long _id = -1; + std::string key; #if PHP_VERSION_ID < 70000 - char *zkey = NULL; - int zkey_len; + char *zkey = NULL; + int zkey_len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &zkey, &zkey_len, &_id) == FAILURE) - { - zend_error(E_ERROR, "key/value required"); - return; - } - key = std::string(zkey, zkey_len); + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &zkey, &zkey_len, &_id) == FAILURE) { + zend_error(E_ERROR, "key/value required"); + return; + } + key = std::string(zkey, zkey_len); #else - zend_string *zkey; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|l", &zkey, &_id) == FAILURE) - { - zend_error(E_ERROR, "key/value required"); - return; - } - key = std::string(zkey->val, zkey->len); + zend_string *zkey; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "S|l", &zkey, &_id) == FAILURE) { + zend_error(E_ERROR, "key/value required"); + return; + } + key = std::string(zkey->val, zkey->len); #endif - if (_id == -1) - { - _id = pinpoint_get_per_thread_id(); - } - char value[1024] = {0}; - int len = pinpoint_get_context_key((NodeID)_id, key.c_str(), value, 1024); - if (len > 0) - { + if (_id == -1) { _id = pinpoint_get_per_thread_id(); } + char value[1024] = {0}; + int len = pinpoint_get_context_key((NodeID) _id, key.c_str(), value, 1024); + if (len > 0) { #if PHP_VERSION_ID < 70000 - RETURN_STRINGL(value, len, 1); + RETURN_STRINGL(value, len, 1); #else - RETURN_STRINGL(value, len); + RETURN_STRINGL(value, len); #endif - } - else - { - RETURN_FALSE; - } + } else { + RETURN_FALSE; + } } -PHP_FUNCTION(pinpoint_start_time) -{ - RETURN_LONG(pinpoint_start_time()); -} +PHP_FUNCTION(pinpoint_start_time) { RETURN_LONG(pinpoint_start_time()); } PHP_FUNCTION(pinpoint_start_trace) { - - long _id = -1; - NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; + long _id = -1; + NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; #if PHP_VERSION_ID < 70000 - zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); #else - zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); #endif - if (_id == -1) - { - id = pinpoint_get_per_thread_id(); - cur_id = pinpoint_start_trace(id); - pinpoint_update_per_thread_id(cur_id); - RETURN_LONG((long)cur_id); - } - else - { - id = (NodeID)_id; - cur_id = pinpoint_start_trace(id); - RETURN_LONG((long)cur_id); - } + if (_id == -1) { + id = pinpoint_get_per_thread_id(); + cur_id = pinpoint_start_trace(id); + pinpoint_update_per_thread_id(cur_id); + RETURN_LONG((long) cur_id); + } else { + id = (NodeID) _id; + cur_id = pinpoint_start_trace(id); + RETURN_LONG((long) cur_id); + } } #if PHP_VERSION_ID >= 80100 void apm_error_cb(int type, zend_string *_error_filename, const uint32_t error_lineno, zend_string *_message) { - char *error_filename = _error_filename->val; - char *msg = _message->val; + char *error_filename = _error_filename->val; + char *msg = _message->val; #elif PHP_VERSION_ID >= 80000 void apm_error_cb(int type, const char *_error_filename, const uint32_t error_lineno, zend_string *_message) { - char *msg = _message->val; - const char *error_filename = _error_filename; + char *msg = _message->val; + const char *error_filename = _error_filename; #else void apm_error_cb(int type, const char *error_filename, const uint error_lineno, const char *format, va_list args) { - char *msg; - va_list args_copy; + char *msg; + va_list args_copy; #if PHP_VERSION_ID < 80000 - TSRMLS_FETCH(); + TSRMLS_FETCH(); #endif - va_copy(args_copy, args); - vspprintf(&msg, 0, format, args_copy); - va_end(args_copy); + va_copy(args_copy, args); + vspprintf(&msg, 0, format, args_copy); + va_end(args_copy); #endif - if (!(EG(error_reporting) & type)) - { - return; - } + if (!(EG(error_reporting) & type)) { return; } - catch_error(pinpoint_get_per_thread_id(), msg, error_filename, error_lineno); + catch_error(pinpoint_get_per_thread_id(), msg, error_filename, error_lineno); - pp_trace("apm_error_cb called"); + pp_trace("apm_error_cb called"); #if PHP_VERSION_ID < 80000 - efree(msg); - /// call origin cb - old_error_cb(type, error_filename, error_lineno, format, args); + efree(msg); + /// call origin cb + old_error_cb(type, error_filename, error_lineno, format, args); #else - old_error_cb(type, _error_filename, error_lineno, _message); + old_error_cb(type, _error_filename, error_lineno, _message); #endif } PHP_FUNCTION(pinpoint_end_trace) { - - long _id = -1; - NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; + long _id = -1; + NodeID id = E_ROOT_NODE, cur_id = E_ROOT_NODE; #if PHP_VERSION_ID < 70000 - zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &_id); #else - zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); + zend_parse_parameters(ZEND_NUM_ARGS(), "|l", &_id); #endif - if (_id == -1) - { - id = pinpoint_get_per_thread_id(); - cur_id = pinpoint_end_trace(id); - pinpoint_update_per_thread_id(cur_id); - RETURN_LONG((long)cur_id); - } - else - { - id = (NodeID)_id; - cur_id = pinpoint_end_trace(id); - RETURN_LONG((long)cur_id); - } + if (_id == -1) { + id = pinpoint_get_per_thread_id(); + cur_id = pinpoint_end_trace(id); + pinpoint_update_per_thread_id(cur_id); + RETURN_LONG((long) cur_id); + } else { + id = (NodeID) _id; + cur_id = pinpoint_end_trace(id); + RETURN_LONG((long) cur_id); + } } PHP_FUNCTION(pinpoint_add_clue) { - std::string key; - std::string value; - long _id = -1; - long _flag = E_LOC_CURRENT; + std::string key; + std::string value; + long _id = -1; + long _flag = E_LOC_CURRENT; #if PHP_VERSION_ID < 70000 - char *zkey = NULL, *zvalue = NULL; - int zkey_len, value_len; + char *zkey = NULL, *zvalue = NULL; + int zkey_len, value_len; - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_id, &_flag) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_add_clue() expects (int, string)."); - return; - } - key = std::string(zkey, zkey_len); - value = std::string(zvalue, value_len); + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_id, &_flag) == FAILURE) { + zend_error(E_ERROR, "pinpoint_add_clue() expects (int, string)."); + return; + } + key = std::string(zkey, zkey_len); + value = std::string(zvalue, value_len); #else - zend_string *zkey; - zend_string *zvalue; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_id, &_flag) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_add_clue() expects (int, string)."); - return; - } - key = std::string(zkey->val, zkey->len); - value = std::string(zvalue->val, zvalue->len); + zend_string *zkey; + zend_string *zvalue; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_id, &_flag) == FAILURE) { + zend_error(E_ERROR, "pinpoint_add_clue() expects (int, string)."); + return; + } + key = std::string(zkey->val, zkey->len); + value = std::string(zvalue->val, zvalue->len); #endif - NodeID Id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID)_id); - pinpoint_add_clue(Id, key.c_str(), value.c_str(), (E_NODE_LOC)_flag); + NodeID Id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID) _id); + pinpoint_add_clue(Id, key.c_str(), value.c_str(), (E_NODE_LOC) _flag); } -PHP_FUNCTION(pinpoint_unique_id) -{ - RETURN_LONG(generate_unique_id()); -} +PHP_FUNCTION(pinpoint_unique_id) { RETURN_LONG(generate_unique_id()); } PHP_FUNCTION(pinpoint_mark_as_error) { - std::string msg; - std::string fileName; - long _lineno = 0; - long _id = -1; + std::string msg; + std::string fileName; + long _lineno = 0; + long _id = -1; #if PHP_VERSION_ID < 70000 - char *zkey = NULL, *zvalue = NULL; - int zkey_len, value_len; - - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_lineno, &_id) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_mark_as_error() expects (string,string,int,int)."); - return; - } - msg = std::string(zkey, zkey_len); - fileName = std::string(zvalue, value_len); + char *zkey = NULL, *zvalue = NULL; + int zkey_len, value_len; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_lineno, &_id) == FAILURE) { + zend_error(E_ERROR, "pinpoint_mark_as_error() expects (string,string,int,int)."); + return; + } + msg = std::string(zkey, zkey_len); + fileName = std::string(zvalue, value_len); #else - zend_string *zkey; - zend_string *zvalue; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_lineno, &_id) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_mark_as_error() expects (string,string,int,int)."); - return; - } - msg = std::string(zkey->val, zkey->len); - fileName = std::string(zvalue->val, zvalue->len); + zend_string *zkey; + zend_string *zvalue; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_lineno, &_id) == FAILURE) { + zend_error(E_ERROR, "pinpoint_mark_as_error() expects (string,string,int,int)."); + return; + } + msg = std::string(zkey->val, zkey->len); + fileName = std::string(zvalue->val, zvalue->len); #endif - NodeID id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID)_id); - catch_error(id, msg.c_str(), fileName.c_str(), _lineno); + NodeID id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID) _id); + catch_error(id, msg.c_str(), fileName.c_str(), _lineno); } PHP_FUNCTION(pinpoint_add_clues) { - std::string key; - std::string value; - long _id = -1; - long _flag = E_LOC_CURRENT; + std::string key; + std::string value; + long _id = -1; + long _flag = E_LOC_CURRENT; #if PHP_VERSION_ID < 70000 - char *zkey = NULL, *zvalue = NULL; - int zkey_len, value_len; - - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_id, &_flag) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_add_clues() expects (int, string)."); - return; - } - key = std::string(zkey, zkey_len); - value = std::string(zvalue, value_len); + char *zkey = NULL, *zvalue = NULL; + int zkey_len, value_len; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &zkey, &zkey_len, &zvalue, &value_len, &_id, &_flag) == FAILURE) { + zend_error(E_ERROR, "pinpoint_add_clues() expects (int, string)."); + return; + } + key = std::string(zkey, zkey_len); + value = std::string(zvalue, value_len); #else - zend_string *zkey; - zend_string *zvalue; - if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_id, &_flag) == FAILURE) - { - zend_error(E_ERROR, "pinpoint_add_clues() expects (int, string)."); - return; - } - key = std::string(zkey->val, zkey->len); - value = std::string(zvalue->val, zvalue->len); + zend_string *zkey; + zend_string *zvalue; + if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS|ll", &zkey, &zvalue, &_id, &_flag) == FAILURE) { + zend_error(E_ERROR, "pinpoint_add_clues() expects (int, string)."); + return; + } + key = std::string(zkey->val, zkey->len); + value = std::string(zvalue->val, zvalue->len); #endif - NodeID id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID)_id); - pinpoint_add_clues(id, key.c_str(), value.c_str(), (E_NODE_LOC)_flag); + NodeID id = (_id == -1) ? (pinpoint_get_per_thread_id()) : ((NodeID) _id); + pinpoint_add_clues(id, key.c_str(), value.c_str(), (E_NODE_LOC) _flag); } /** @@ -518,126 +466,109 @@ PHP_FUNCTION(pinpoint_add_clues) PHP_FUNCTION(pinpoint_get_func_ref_args) { #if PHP_VERSION_ID < 70000 - void **p; - int arg_count; - int i; - zend_execute_data *ex = EG(current_execute_data)->prev_execute_data; - - if (!ex || !ex->function_state.arguments) - { - zend_error(E_WARNING, "pinpoint_get_func_ref_args(): Called from the global scope - no function context"); - RETURN_FALSE; - } - - p = ex->function_state.arguments; - arg_count = (int)(zend_uintptr_t)*p; /* this is the amount of arguments passed to func_get_args(); */ - - array_init_size(return_value, arg_count); - for (i = 0; i < arg_count; i++) - { - zval *element, *arg; - - arg = *((zval **)(p - (arg_count - i))); - element = arg; - Z_ADDREF_P(element); - - zend_hash_next_index_insert(return_value->value.ht, &element, sizeof(zval *), NULL); - } + void **p; + int arg_count; + int i; + zend_execute_data *ex = EG(current_execute_data)->prev_execute_data; + + if (!ex || !ex->function_state.arguments) { + zend_error(E_WARNING, + "pinpoint_get_func_ref_args(): Called from the " + "global scope - no function context"); + RETURN_FALSE; + } + + p = ex->function_state.arguments; + arg_count = (int) (zend_uintptr_t) *p; /* this is the amount of arguments passed + to func_get_args(); */ + + array_init_size(return_value, arg_count); + for (i = 0; i < arg_count; i++) { + zval *element, *arg; + + arg = *((zval **) (p - (arg_count - i))); + element = arg; + Z_ADDREF_P(element); + + zend_hash_next_index_insert(return_value->value.ht, &element, sizeof(zval *), NULL); + } #else - zval *p, *q; - uint32_t arg_count, first_extra_arg; - uint32_t i, n; - zend_execute_data *ex = EX(prev_execute_data); - - if (ZEND_CALL_INFO(ex) & ZEND_CALL_CODE) - { - zend_error(E_WARNING, "pinpoint_get_func_ref_args(): Called from the global scope - no function context"); - RETURN_FALSE; - } + zval *p, *q; + uint32_t arg_count, first_extra_arg; + uint32_t i, n; + zend_execute_data *ex = EX(prev_execute_data); + + if (ZEND_CALL_INFO(ex) & ZEND_CALL_CODE) { + zend_error(E_WARNING, + "pinpoint_get_func_ref_args(): Called from the " + "global scope - no function context"); + RETURN_FALSE; + } #if PHP_VERSION_ID > 70033 - if (zend_forbid_dynamic_call("pinpoint_get_func_ref_args()") == FAILURE) - { - RETURN_FALSE; - } + if (zend_forbid_dynamic_call("pinpoint_get_func_ref_args()") == FAILURE) { RETURN_FALSE; } #endif - arg_count = ZEND_CALL_NUM_ARGS(ex); - - array_init_size(return_value, arg_count); - if (arg_count) - { - first_extra_arg = ex->func->op_array.num_args; - zend_hash_real_init(Z_ARRVAL_P(return_value), 1); - ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) - { - i = 0; - n = 0; - p = ZEND_CALL_ARG(ex, 1); - if (arg_count > first_extra_arg) - { - while (i < first_extra_arg) - { - q = p; - if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) - { - // ZVAL_DEREF(q); - if (Z_OPT_REFCOUNTED_P(q)) - { - Z_ADDREF_P(q); - } - n++; - } - ZEND_HASH_FILL_ADD(q); - p++; - i++; - } - p = ZEND_CALL_VAR_NUM(ex, ex->func->op_array.last_var + ex->func->op_array.T); - } - while (i < arg_count) - { - q = p; - if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) - { - // ZVAL_DEREF(q); - if (Z_OPT_REFCOUNTED_P(q)) - { - Z_ADDREF_P(q); - } - n++; - } - ZEND_HASH_FILL_ADD(q); - p++; - i++; - } - } - ZEND_HASH_FILL_END(); - Z_ARRVAL_P(return_value)->nNumOfElements = n; - } + arg_count = ZEND_CALL_NUM_ARGS(ex); + + array_init_size(return_value, arg_count); + if (arg_count) { + first_extra_arg = ex->func->op_array.num_args; + zend_hash_real_init(Z_ARRVAL_P(return_value), 1); + ZEND_HASH_FILL_PACKED(Z_ARRVAL_P(return_value)) + { + i = 0; + n = 0; + p = ZEND_CALL_ARG(ex, 1); + if (arg_count > first_extra_arg) { + while (i < first_extra_arg) { + q = p; + if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) { + // ZVAL_DEREF(q); + if (Z_OPT_REFCOUNTED_P(q)) { Z_ADDREF_P(q); } + n++; + } + ZEND_HASH_FILL_ADD(q); + p++; + i++; + } + p = ZEND_CALL_VAR_NUM(ex, ex->func->op_array.last_var + ex->func->op_array.T); + } + while (i < arg_count) { + q = p; + if (EXPECTED(Z_TYPE_INFO_P(q) != IS_UNDEF)) { + // ZVAL_DEREF(q); + if (Z_OPT_REFCOUNTED_P(q)) { Z_ADDREF_P(q); } + n++; + } + ZEND_HASH_FILL_ADD(q); + p++; + i++; + } + } + ZEND_HASH_FILL_END(); + Z_ARRVAL_P(return_value)->nNumOfElements = n; + } #endif } PHP_FUNCTION(pinpoint_tracelimit) { - - long timestamp = -1; + long timestamp = -1; #if PHP_VERSION_ID < 70000 - zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", ×tamp); + zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", ×tamp); #else - zend_parse_parameters(ZEND_NUM_ARGS(), "|l", ×tamp); + zend_parse_parameters(ZEND_NUM_ARGS(), "|l", ×tamp); #endif - timestamp = (timestamp == -1) ? (time(NULL)) : (timestamp); + timestamp = (timestamp == -1) ? (time(NULL)) : (timestamp); - if (check_tracelimit(timestamp) == 1) - { - RETURN_TRUE; - } - else - { - RETURN_FALSE; - } + if (check_tracelimit(timestamp) == 1) { + RETURN_TRUE; + } else { + RETURN_FALSE; + } } /* {{{ php_pinpioint_php_init_globals @@ -646,7 +577,7 @@ PHP_FUNCTION(pinpoint_tracelimit) */ static void php_pinpoint_php_init_globals(zend_pinpoint_php_globals *pinpoint_php_globals) { - memset(pinpoint_php_globals, 0, sizeof(zend_pinpoint_php_globals)); + memset(pinpoint_php_globals, 0, sizeof(zend_pinpoint_php_globals)); } /* }}} */ @@ -656,28 +587,25 @@ static void php_pinpoint_php_init_globals(zend_pinpoint_php_globals *pinpoint_ph PHP_MINIT_FUNCTION(pinpoint_php) { - ZEND_INIT_MODULE_GLOBALS(pinpoint_php, php_pinpoint_php_init_globals, NULL); - REGISTER_INI_ENTRIES(); - - old_error_cb = zend_error_cb; - zend_error_cb = apm_error_cb; - // global_agent_info. - strncpy(global_agent_info.co_host, PPG(co_host), MAX_ADDRESS_SIZE); - global_agent_info.inter_flag = PPG(debug_report); - global_agent_info.timeout_ms = PPG(w_timeout_ms); - global_agent_info.trace_limit = PPG(tracelimit); - global_agent_info.agent_type = 1500; // PHP - - if (PPG(utest_flag) == 1) - { - global_agent_info.inter_flag |= E_UTEST; - } - else - { - register_error_cb(pinpoint_log); - } - - return SUCCESS; + ZEND_INIT_MODULE_GLOBALS(pinpoint_php, php_pinpoint_php_init_globals, NULL); + REGISTER_INI_ENTRIES(); + + old_error_cb = zend_error_cb; + zend_error_cb = apm_error_cb; + // global_agent_info. + strncpy(global_agent_info.co_host, PPG(co_host), MAX_ADDRESS_SIZE); + global_agent_info.inter_flag = PPG(debug_report); + global_agent_info.timeout_ms = PPG(w_timeout_ms); + global_agent_info.trace_limit = PPG(tracelimit); + global_agent_info.agent_type = 1500; // PHP + + if (PPG(utest_flag) == 1) { + global_agent_info.inter_flag |= E_UTEST; + } else { + register_error_cb(pinpoint_log); + } + + return SUCCESS; } /* }}} */ @@ -685,11 +613,11 @@ PHP_MINIT_FUNCTION(pinpoint_php) */ PHP_MSHUTDOWN_FUNCTION(pinpoint_php) { - /* uncomment this line if you have INI entries - UNREGISTER_INI_ENTRIES(); - */ + /* uncomment this line if you have INI entries + UNREGISTER_INI_ENTRIES(); + */ - return SUCCESS; + return SUCCESS; } /* }}} */ @@ -698,12 +626,11 @@ PHP_MSHUTDOWN_FUNCTION(pinpoint_php) */ PHP_RINIT_FUNCTION(pinpoint_php) { - #if defined(COMPILE_DL_PINPIOINT_PHP) && defined(ZTS) - ZEND_TSRMLS_CACHE_UPDATE(); + ZEND_TSRMLS_CACHE_UPDATE(); #endif - return SUCCESS; + return SUCCESS; } /* }}} */ @@ -712,14 +639,13 @@ PHP_RINIT_FUNCTION(pinpoint_php) */ PHP_RSHUTDOWN_FUNCTION(pinpoint_php) { - NodeID _id = pinpoint_get_per_thread_id(); - if (_id != 0) - { - pinpoint_force_end_trace(_id, 300); - pinpoint_update_per_thread_id(E_ROOT_NODE); - } + NodeID _id = pinpoint_get_per_thread_id(); + if (_id != 0) { + pinpoint_force_end_trace(_id, 300); + pinpoint_update_per_thread_id(E_ROOT_NODE); + } - return SUCCESS; + return SUCCESS; } /* }}} */ @@ -727,23 +653,22 @@ PHP_RSHUTDOWN_FUNCTION(pinpoint_php) */ PHP_MINFO_FUNCTION(pinpoint_php) { - php_info_print_table_start(); - php_info_print_table_header(2, "pinpoint_php support", "enabled"); - php_info_print_table_end(); + php_info_print_table_start(); + php_info_print_table_header(2, "pinpoint_php support", "enabled"); + php_info_print_table_end(); - // /* Remove comments if you have entries in php.ini - DISPLAY_INI_ENTRIES(); - // */ + // /* Remove comments if you have entries in php.ini + DISPLAY_INI_ENTRIES(); + // */ } /* }}} */ void pinpoint_log(char *msg) { - #if PHP_VERSION_ID >= 70100 - php_log_err_with_severity(msg, LOG_DEBUG); + php_log_err_with_severity(msg, LOG_DEBUG); #else - TSRMLS_FETCH(); - php_log_err(msg TSRMLS_CC); + TSRMLS_FETCH(); + php_log_err(msg TSRMLS_CC); #endif }