From 78a61f119871e430e3d99bbc13d1b750d7e643d3 Mon Sep 17 00:00:00 2001 From: hxy7yx <1595670487@qq.com> Date: Wed, 15 Nov 2023 11:17:05 +0800 Subject: [PATCH] improve: core/adapter log level --- include/neuron/msg.h | 8 +-- include/neuron/utils/log.h | 24 +++++++++ plugins/restful/adapter_handle.c | 15 +++--- plugins/restful/log_handle.c | 72 ++++++++----------------- src/adapter/adapter.c | 16 +++--- src/adapter/adapter_internal.h | 3 +- src/base/neu_plugin_common.c | 1 - src/core/manager.c | 93 +++++++++++--------------------- src/core/manager_internal.h | 9 ++-- src/core/node_manager.c | 3 +- src/parser/neu_json_node.h | 4 +- 11 files changed, 109 insertions(+), 139 deletions(-) diff --git a/include/neuron/msg.h b/include/neuron/msg.h index e145fb03..53c09d7e 100644 --- a/include/neuron/msg.h +++ b/include/neuron/msg.h @@ -36,7 +36,7 @@ extern "C" { typedef struct { neu_node_running_state_e running; neu_node_link_state_e link; - char log_level[NEU_LOG_LEVEL_LEN]; + int log_level; } neu_node_state_t; typedef enum neu_reqresp_type { @@ -624,7 +624,7 @@ typedef struct neu_req_get_node_state { typedef struct neu_resp_get_node_state { neu_node_state_t state; uint16_t rtt; // round trip time in milliseconds - char core_level[NEU_LOG_LEVEL_LEN]; + int core_level; } neu_resp_get_node_state_t; typedef struct neu_req_get_nodes_state { @@ -644,7 +644,7 @@ inline static UT_icd neu_nodes_state_t_icd() } typedef struct { UT_array *states; // array of neu_nodes_state_t - char core_level[NEU_LOG_LEVEL_LEN]; + int core_level; } neu_resp_get_nodes_state_t, neu_reqresp_nodes_state_t; typedef struct { @@ -1086,7 +1086,7 @@ typedef struct { typedef struct neu_req_update_log_level { char node[NEU_NODE_NAME_LEN]; - char log_level[NEU_LOG_LEVEL_LEN]; + int log_level; bool core; } neu_req_update_log_level_t; diff --git a/include/neuron/utils/log.h b/include/neuron/utils/log.h index 3969138e..d1efff57 100644 --- a/include/neuron/utils/log.h +++ b/include/neuron/utils/log.h @@ -25,8 +25,32 @@ config_ **/ #include "utils/zlog.h" +#include "define.h" + extern zlog_category_t *neuron; +inline static const char *log_level_to_str(int level) +{ + switch (level) { + case ZLOG_LEVEL_FATAL: + return NEU_LOG_LEVEL_FATAL; + case ZLOG_LEVEL_ERROR: + return NEU_LOG_LEVEL_ERROR; + case ZLOG_LEVEL_WARN: + return NEU_LOG_LEVEL_WARN; + case ZLOG_LEVEL_NOTICE: + return NEU_LOG_LEVEL_NOTICE; + case ZLOG_LEVEL_INFO: + return NEU_LOG_LEVEL_INFO; + case ZLOG_LEVEL_DEBUG: + return NEU_LOG_LEVEL_DEBUG; + default: + return "UNKNOWN"; + } +} + +#define nlog_level_change(level) zlog_level_switch(neuron, level) + #define nlog_fatal(...) \ zlog(neuron, __FILE__, sizeof(__FILE__) - 1, __func__, \ sizeof(__func__) - 1, __LINE__, ZLOG_LEVEL_FATAL, __VA_ARGS__) diff --git a/plugins/restful/adapter_handle.c b/plugins/restful/adapter_handle.c index 2ca0249c..60552507 100644 --- a/plugins/restful/adapter_handle.c +++ b/plugins/restful/adapter_handle.c @@ -330,11 +330,11 @@ void handle_get_node_state_resp(nng_aio *aio, neu_resp_get_node_state_t *state) neu_json_get_node_state_resp_t res = { 0 }; char * result = NULL; - res.link = state->state.link; - res.running = state->state.running; - res.rtt = state->rtt; - res.log_level = state->state.log_level; - strcpy(res.core_level, state->core_level); + res.link = state->state.link; + res.running = state->state.running; + res.rtt = state->rtt; + res.log_level = (char *) log_level_to_str(state->state.log_level); + res.core_level = (char *) log_level_to_str(state->core_level); neu_json_encode_by_fn(&res, neu_json_encode_get_node_state_resp, &result); @@ -359,10 +359,11 @@ void handle_get_nodes_state_resp(nng_aio * aio, states_res.nodes[index].running = state->state.running; states_res.nodes[index].link = state->state.link; states_res.nodes[index].rtt = state->rtt; - states_res.nodes[index].log_level = state->state.log_level; + states_res.nodes[index].log_level = + (char *) log_level_to_str(state->state.log_level); } - strcpy(states_res.core_level, states->core_level); + states_res.core_level = (char *) log_level_to_str(states->core_level); neu_json_encode_by_fn(&states_res, neu_json_encode_get_nodes_state_resp, &result); diff --git a/plugins/restful/log_handle.c b/plugins/restful/log_handle.c index d675f094..6b7c674e 100644 --- a/plugins/restful/log_handle.c +++ b/plugins/restful/log_handle.c @@ -113,78 +113,48 @@ void handle_log_level(nng_aio *aio) NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT( aio, neu_json_update_log_level_req_t, neu_json_decode_update_log_level_req, { - int ret = 0; - neu_reqresp_head_t header = { 0 }; - neu_req_update_log_level_t cmd = { 0 }; - int log_level; + neu_reqresp_head_t header = { 0 }; + neu_req_update_log_level_t cmd = { 0 }; + int log_level = -1; if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_DEBUG)) { log_level = ZLOG_LEVEL_DEBUG; - strcpy(cmd.log_level, NEU_LOG_LEVEL_DEBUG); } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_INFO)) { log_level = ZLOG_LEVEL_INFO; - strcpy(cmd.log_level, NEU_LOG_LEVEL_INFO); } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_NOTICE)) { log_level = ZLOG_LEVEL_NOTICE; - strcpy(cmd.log_level, NEU_LOG_LEVEL_NOTICE); } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_WARN)) { log_level = ZLOG_LEVEL_WARN; - strcpy(cmd.log_level, NEU_LOG_LEVEL_WARN); } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_ERROR)) { log_level = ZLOG_LEVEL_ERROR; - strcpy(cmd.log_level, NEU_LOG_LEVEL_ERROR); } else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_FATAL)) { log_level = ZLOG_LEVEL_FATAL; - strcpy(cmd.log_level, NEU_LOG_LEVEL_FATAL); } else { - strcpy(cmd.log_level, "unknow"); - nlog_error( - "Failed to modify log_level of the node, node_name:%s, ", - req->node_name); + nlog_error("Failed to modify log_level of the node, " + "node_name:%s, log_level: %s", + req->node_name, req->log_level); + } + + if (log_level == -1) { NEU_JSON_RESPONSE_ERROR(NEU_ERR_PARAM_IS_WRONG, { neu_http_response(aio, error_code.error, result_error); }); - goto end; - } - if (req->core) { - zlog_category_t *neuron = zlog_get_category("neuron"); - ret = zlog_level_switch(neuron, log_level); + } else { + header.ctx = aio; + header.type = NEU_REQ_UPDATE_LOG_LEVEL; + cmd.core = req->core; + cmd.log_level = log_level; + if (req->node_name != NULL) { + strcpy(cmd.node, req->node_name); + } + + int ret = neu_plugin_op(plugin, header, &cmd); if (ret != 0) { - nlog_error( - "Failed to modify log_level of the core, ret: %d", ret); - NEU_JSON_RESPONSE_ERROR(NEU_ERR_EINTERNAL, { - neu_http_response(aio, error_code.error, result_error); + NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, { + neu_http_response(aio, NEU_ERR_IS_BUSY, result_error); }); - goto end; } } - - if (req->node_name) { - zlog_category_t *ct = zlog_get_category(req->node_name); - strcpy(cmd.node, req->node_name); - ret = zlog_level_switch(ct, log_level); - if (ret != 0) { - nlog_error( - "Failed to modify log_level of the node, node_name:%s, " - "ret: %d,", - req->node_name, ret); - NEU_JSON_RESPONSE_ERROR(0, { - neu_http_response(aio, error_code.error, result_error); - }); - goto end; - } - } - - header.ctx = aio; - header.type = NEU_REQ_UPDATE_LOG_LEVEL; - cmd.core = req->core; - ret = neu_plugin_op(plugin, header, &cmd); - if (ret != 0) { - NEU_JSON_RESPONSE_ERROR(NEU_ERR_IS_BUSY, { - neu_http_response(aio, NEU_ERR_IS_BUSY, result_error); - }); - } - end:; }) } diff --git a/src/adapter/adapter.c b/src/adapter/adapter.c index 789e5ad4..8231746b 100644 --- a/src/adapter/adapter.c +++ b/src/adapter/adapter.c @@ -147,6 +147,7 @@ neu_adapter_t *neu_adapter_create(neu_adapter_info_t *info, bool load) adapter->module = info->module; adapter->timestamp_lev = 0; adapter->trans_data_port = 0; + adapter->log_level = ZLOG_LEVEL_NOTICE; struct sockaddr_in remote = { .sin_family = AF_INET, @@ -487,9 +488,7 @@ static int adapter_command(neu_adapter_t *adapter, neu_reqresp_head_t header, } case NEU_REQ_UPDATE_LOG_LEVEL: { neu_req_update_log_level_t *cmd = (neu_req_update_log_level_t *) data; - if (cmd->node != NULL) { - strcpy(pheader->receiver, cmd->node); - } + strcpy(pheader->receiver, cmd->node); break; } default: @@ -1234,7 +1233,12 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data) break; } case NEU_REQ_UPDATE_LOG_LEVEL: { + neu_req_update_log_level_t *cmd = + (neu_req_update_log_level_t *) &header[1]; neu_resp_error_t error = { 0 }; + adapter->log_level = cmd->log_level; + zlog_level_switch(neu_plugin_to_plugin_common(adapter->plugin)->log, + cmd->log_level); struct timeval tv = { 0 }; gettimeofday(&tv, NULL); @@ -1426,9 +1430,9 @@ neu_node_state_t neu_adapter_get_state(neu_adapter_t *adapter) neu_node_state_t state = { 0 }; neu_plugin_common_t *common = neu_plugin_to_plugin_common(adapter->plugin); - state.link = common->link_state; - state.running = adapter->state; - strcpy(state.log_level, common->log_level); + state.link = common->link_state; + state.running = adapter->state; + state.log_level = adapter->log_level; return state; } diff --git a/src/adapter/adapter_internal.h b/src/adapter/adapter_internal.h index d9616b0e..7fc9ab5c 100644 --- a/src/adapter/adapter_internal.h +++ b/src/adapter/adapter_internal.h @@ -33,8 +33,6 @@ struct neu_adapter { neu_node_running_state_e state; - char log_level[NEU_LOG_LEVEL_LEN]; - adapter_callbacks_t cb_funs; void * handle; @@ -59,6 +57,7 @@ struct neu_adapter { // metrics neu_node_metrics_t *metrics; + int log_level; }; typedef void (*adapter_handler)(neu_adapter_t * adapter, diff --git a/src/base/neu_plugin_common.c b/src/base/neu_plugin_common.c index 781b61a7..5616d05e 100644 --- a/src/base/neu_plugin_common.c +++ b/src/base/neu_plugin_common.c @@ -31,7 +31,6 @@ void neu_plugin_common_init(neu_plugin_common_t *common) { common->magic = NEU_PLUGIN_MAGIC_NUMBER; common->link_state = NEU_NODE_LINK_STATE_DISCONNECTED; - strcpy(common->log_level, NEU_LOG_LEVEL_NOTICE); } bool neu_plugin_common_check(neu_plugin_t *plugin) diff --git a/src/core/manager.c b/src/core/manager.c index de8dca3f..85e69a1a 100644 --- a/src/core/manager.c +++ b/src/core/manager.c @@ -101,6 +101,7 @@ neu_manager_t *neu_manager_create() manager->node_manager = neu_node_manager_create(); manager->subscribe_manager = neu_subscribe_manager_create(); manager->template_manager = neu_template_manager_create(); + manager->log_level = ZLOG_LEVEL_NOTICE; manager->server_fd = socket(AF_INET, SOCK_DGRAM | SOCK_NONBLOCK, IPPROTO_UDP); @@ -1161,11 +1162,8 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data) neu_resp_get_nodes_state_t resp = { 0 }; UT_array *states = neu_node_manager_get_state(manager->node_manager); - neu_adapter_t *adapter_core = - neu_node_manager_find(manager->node_manager, "default-dashboard"); - strcpy(resp.core_level, - neu_plugin_to_plugin_common(adapter_core->plugin)->log_level); - resp.states = utarray_clone(states); + resp.core_level = manager->log_level; + resp.states = utarray_clone(states); strcpy(header->receiver, header->sender); strcpy(header->sender, "manager"); @@ -1219,13 +1217,6 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data) neu_msg_exchange(header); reply(manager, header, &e); } else { - neu_resp_get_node_state_t *resp = - (neu_resp_get_node_state_t *) &header[1]; - neu_adapter_t *adapter_core = neu_node_manager_find( - manager->node_manager, "default-dashboard"); - strcpy( - resp->core_level, - neu_plugin_to_plugin_common(adapter_core->plugin)->log_level); forward_msg(manager, header, header->receiver); } @@ -1427,12 +1418,19 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data) case NEU_RESP_GET_NDRIVER_TAGS: case NEU_RESP_GET_GROUP: case NEU_RESP_GET_NODE_SETTING: - case NEU_RESP_GET_NODE_STATE: case NEU_RESP_ERROR: case NEU_RESP_READ_GROUP: forward_msg(manager, header, header->receiver); break; + case NEU_RESP_GET_NODE_STATE: { + neu_resp_get_node_state_t *resp = + (neu_resp_get_node_state_t *) &header[1]; + + resp->core_level = manager->log_level; + forward_msg(manager, header, header->receiver); + break; + } case NEU_REQ_ADD_NDRIVER_MAP: { neu_req_ndriver_map_t *cmd = (neu_req_ndriver_map_t *) &header[1]; neu_resp_error_t error = { 0 }; @@ -1514,58 +1512,31 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data) (neu_req_update_log_level_t *) &header[1]; if (cmd->core) { - if (strcmp(header->receiver, "") == 0) { - neu_adapter_t *adapter_core = neu_node_manager_find( - manager->node_manager, "default-dashboard"); - strcpy(neu_plugin_to_plugin_common(adapter_core->plugin) - ->log_level, - cmd->log_level); - neu_resp_error_t error = { 0 }; - neu_msg_exchange(header); - header->type = NEU_RESP_ERROR; - reply(manager, header, &error); - } else { - if (neu_node_manager_find(manager->node_manager, - header->receiver) == NULL) { - neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST }; - header->type = NEU_RESP_ERROR; - neu_msg_exchange(header); - reply(manager, header, &e); - } else { - neu_adapter_t *adapter_core = neu_node_manager_find( - manager->node_manager, "default-dashboard"); - strcpy(neu_plugin_to_plugin_common(adapter_core->plugin) - ->log_level, - cmd->log_level); - neu_adapter_t *adapter_log = neu_node_manager_find( - manager->node_manager, header->receiver); - strcpy(neu_plugin_to_plugin_common(adapter_log->plugin) - ->log_level, - cmd->log_level); - forward_msg(manager, header, header->receiver); - } - } - } else { - if (strcmp(header->receiver, "") == 0) { - neu_resp_error_t e = { .error = NEU_ERR_PARAM_IS_WRONG }; + manager->log_level = cmd->log_level; + nlog_level_change(manager->log_level); + } + + if (strlen(cmd->node) > 0) { + if (neu_node_manager_find(manager->node_manager, + header->receiver) == NULL) { + neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST }; header->type = NEU_RESP_ERROR; neu_msg_exchange(header); reply(manager, header, &e); } else { - if (neu_node_manager_find(manager->node_manager, - header->receiver) == NULL) { - neu_resp_error_t e = { .error = NEU_ERR_NODE_NOT_EXIST }; - header->type = NEU_RESP_ERROR; - neu_msg_exchange(header); - reply(manager, header, &e); - } else { - neu_adapter_t *adapter_log = neu_node_manager_find( - manager->node_manager, header->receiver); - strcpy(neu_plugin_to_plugin_common(adapter_log->plugin) - ->log_level, - cmd->log_level); - forward_msg(manager, header, header->receiver); - } + forward_msg(manager, header, header->receiver); + } + } else { + if (cmd->core) { + neu_resp_error_t e = { .error = NEU_ERR_SUCCESS }; + header->type = NEU_RESP_ERROR; + neu_msg_exchange(header); + reply(manager, header, &e); + } else { + neu_resp_error_t e = { .error = NEU_ERR_PARAM_IS_WRONG }; + header->type = NEU_RESP_ERROR; + neu_msg_exchange(header); + reply(manager, header, &e); } } diff --git a/src/core/manager_internal.h b/src/core/manager_internal.h index 874ce1d1..ea39d136 100644 --- a/src/core/manager_internal.h +++ b/src/core/manager_internal.h @@ -29,9 +29,10 @@ #include "template_manager.h" typedef struct neu_manager { - int server_fd; - uint8_t buf[NEU_MSG_MAX_SIZE]; - uint8_t recv_buf[NEU_MSG_MAX_SIZE]; + int server_fd; + uint8_t buf[NEU_MSG_MAX_SIZE]; + uint8_t recv_buf[NEU_MSG_MAX_SIZE]; + neu_events_t * events; neu_event_io_t *loop; @@ -43,6 +44,8 @@ typedef struct neu_manager { neu_event_timer_t *timer_timestamp; int64_t timestamp_lev_manager; + + int log_level; } neu_manager_t; int neu_manager_add_plugin(neu_manager_t *manager, const char *library); diff --git a/src/core/node_manager.c b/src/core/node_manager.c index 78ecca9f..003dd6a4 100644 --- a/src/core/node_manager.c +++ b/src/core/node_manager.c @@ -414,8 +414,7 @@ UT_array *neu_node_manager_get_state(neu_node_manager_t *mgr) state.state.running = el->adapter->state; state.state.link = neu_plugin_to_plugin_common(el->adapter->plugin)->link_state; - strcpy(state.state.log_level, - neu_plugin_to_plugin_common(el->adapter->plugin)->log_level); + state.state.log_level = el->adapter->log_level; neu_metric_entry_t *e = NULL; if (NULL != el->adapter->metrics) { HASH_FIND_STR(el->adapter->metrics->entries, diff --git a/src/parser/neu_json_node.h b/src/parser/neu_json_node.h index e3268701..b1f51b5e 100644 --- a/src/parser/neu_json_node.h +++ b/src/parser/neu_json_node.h @@ -54,7 +54,7 @@ typedef struct { int64_t link; int64_t rtt; char * log_level; - char core_level[NEU_LOG_LEVEL_LEN]; + char * core_level; } neu_json_get_node_state_resp_t; int neu_json_encode_get_node_state_resp(void *json_object, void *param); @@ -70,7 +70,7 @@ typedef struct { typedef struct { uint16_t n_node; neu_json_get_nodes_state_t *nodes; - char core_level[NEU_LOG_LEVEL_LEN]; + char * core_level; } neu_json_get_nodes_state_resp_t; int neu_json_encode_get_nodes_state_resp(void *json_object, void *param);