GithubStar/neuron
1
0
Fork 0
mirror of https://github.com/emqx/neuron.git synced 2026-10-16 20:30:39 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat(log):global config

Browse Source
This commit is contained in:
hxy7yx
2025-09-14 19:02:07 -07:00
parent 8233d1082b
commit b1c600e0f1
13 changed files with 382 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/api/cn/http.md
+57
View File
@@ -1844,6 +1844,63 @@ node 字段选填，不填此字段时 core 不可以为 false，此时仅切换
}
```
## 修改全局日志等级
*PUT* /api/v2/log/global
### 请求头部
**Authorization** Bearer \<token\>
### 响应状态
* 200 OK
* 500
* 1001 内部错误
* 1010 程序繁忙
### 请求体
```json
{
"level": "debug",
}
```
::: tip
修改所有节点以及核心的日志等级。
:::
### 响应
```json
{
"error": 0
}
```
## 获取全局日志等级
*GET* /api/v2/log/global
### 请求头部
**Authorization** Bearer \<token\>
### 响应状态
* 200
* 500
* 1001 服务器内部错误
### 响应
```json
{
"level": "info",
}
```
## 批量添加 Drivers
*PUT* /api/v2/global/drivers
docs/api/english/http.md
+57
View File
@@ -1825,6 +1825,63 @@ The node field is optional. If this field is not filled in, the core cannot be f
}
```
## Update global log level
*PUT* /api/v2/log/global
### Request Headers
**Authorization** Bearer \<token\>
### Response Status
* 200 OK
* 500
* 1001 internal error
* 1010 is busy
### Body
```json
{
"level": "debug",
}
```
::: tip
Update log level of all nodes, including the core log level.
:::
### Response
```json
{
"error": 0
}
```
## Get global log level
*GET* /api/v2/log/global
### Request Headers
**Authorization** Bearer \<token\>
### Response Status
* 200
* 500
* 1001 internal error
### Response
```json
{
"level": "info",
}
```
## Get file list information
*GET* /api/v2/file/info
include/neuron/msg.h
+16 -4
View File
@@ -127,6 +127,8 @@ typedef enum neu_reqresp_type {
NEU_REQ_ADD_DRIVERS,
NEU_REQ_UPDATE_LOG_LEVEL,
NEU_REQ_UPDATE_GLOBAL_LOG_LEVEL,
NEU_REQ_UPDATE_NODE_LOG_LEVEL,
NEU_REQ_PRGFILE_UPLOAD,
NEU_REQ_PRGFILE_PROCESS,
@@ -265,10 +267,12 @@ static const char *neu_reqresp_type_string_t[] = {
[NEU_REQ_ADD_DRIVERS] = "NEU_REQ_ADD_DRIVERS",
[NEU_REQ_UPDATE_LOG_LEVEL] = "NEU_REQ_UPDATE_LOG_LEVEL",
[NEU_REQ_PRGFILE_UPLOAD] = "NEU_REQ_PRGFILE_UPLOAD",
[NEU_REQ_PRGFILE_PROCESS] = "NEU_REQ_PRGFILE_PROCESS",
[NEU_RESP_PRGFILE_PROCESS] = "NEU_RESP_PRGFILE_PROCESS",
[NEU_REQ_UPDATE_LOG_LEVEL] = "NEU_REQ_UPDATE_LOG_LEVEL",
[NEU_REQ_UPDATE_GLOBAL_LOG_LEVEL] = "NEU_REQ_UPDATE_GLOBAL_LOG_LEVEL",
[NEU_REQ_UPDATE_NODE_LOG_LEVEL] = "NEU_REQ_UPDATE_NODE_LOG_LEVEL",
[NEU_REQ_PRGFILE_UPLOAD] = "NEU_REQ_PRGFILE_UPLOAD",
[NEU_REQ_PRGFILE_PROCESS] = "NEU_REQ_PRGFILE_PROCESS",
[NEU_RESP_PRGFILE_PROCESS] = "NEU_RESP_PRGFILE_PROCESS",
[NEU_REQ_SCAN_TAGS] = "NEU_REQ_SCAN_TAGS",
[NEU_RESP_SCAN_TAGS] = "NEU_RESP_SCAN_TAGS",
@@ -1573,6 +1577,14 @@ typedef struct neu_req_update_log_level {
bool core;
} neu_req_update_log_level_t;
typedef struct neu_req_update_global_log_level {
int log_level;
} neu_req_update_global_log_level_t;
typedef struct neu_req_update_node_log_level {
int log_level;
} neu_req_update_node_log_level_t;
void neu_msg_gen(neu_reqresp_head_t *header, void *data);
inline static void neu_msg_exchange(neu_reqresp_head_t *header)
plugins/restful/handle.c
+12
View File
@@ -414,6 +414,18 @@ static struct neu_http_handler rest_handlers[] = {
.url = "/api/v2/log/level",
.value.handler = handle_log_level,
},
{
.method = NEU_HTTP_METHOD_PUT,
.type = NEU_HTTP_HANDLER_FUNCTION,
.url = "/api/v2/log/global",
.value.handler = handle_global_log_level,
},
{
.method = NEU_HTTP_METHOD_GET,
.type = NEU_HTTP_HANDLER_FUNCTION,
.url = "/api/v2/log/global",
.value.handler = handle_get_global_log_level,
},
{
.method = NEU_HTTP_METHOD_GET,
.type = NEU_HTTP_HANDLER_FUNCTION,
plugins/restful/log_handle.c
+91
View File
@@ -31,6 +31,7 @@
#include <nng/nng.h>
#include <nng/supplemental/http/http.h>
#include "core/manager.h"
#include "define.h"
#include "errcodes.h"
#include "handle.h"
@@ -104,6 +105,96 @@ void handle_log_level(nng_aio *aio)
})
}
void handle_global_log_level(nng_aio *aio)
{
neu_plugin_t *plugin = neu_rest_get_plugin();
NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
aio, neu_json_update_global_log_level_req_t,
neu_json_decode_update_global_log_level_req, {
neu_reqresp_head_t header = { 0 };
neu_req_update_global_log_level_t cmd = { 0 };
int log_level = -1;
if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_DEBUG)) {
log_level = ZLOG_LEVEL_DEBUG;
} else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_INFO)) {
log_level = ZLOG_LEVEL_INFO;
} else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_NOTICE)) {
log_level = ZLOG_LEVEL_NOTICE;
} else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_WARN)) {
log_level = ZLOG_LEVEL_WARN;
} else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_ERROR)) {
log_level = ZLOG_LEVEL_ERROR;
} else if (0 == strcmp(req->log_level, NEU_LOG_LEVEL_FATAL)) {
log_level = ZLOG_LEVEL_FATAL;
} else {
nlog_error("Failed to set global log_level, invalid level: %s",
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);
});
} else {
header.ctx = aio;
header.type = NEU_REQ_UPDATE_GLOBAL_LOG_LEVEL;
header.otel_trace_type = NEU_OTEL_TRACE_TYPE_REST_COMM;
cmd.log_level = log_level;
nlog_info(
"Setting global log level to %s for core and all drivers",
req->log_level);
int 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);
});
}
}
})
}
void handle_get_global_log_level(nng_aio *aio)
{
NEU_VALIDATE_JWT(aio);
int global_log_level = neu_manager_get_global_log_level();
const char *log_level_str = "unknown";
switch (global_log_level) {
case ZLOG_LEVEL_DEBUG:
log_level_str = NEU_LOG_LEVEL_DEBUG;
break;
case ZLOG_LEVEL_INFO:
log_level_str = NEU_LOG_LEVEL_INFO;
break;
case ZLOG_LEVEL_NOTICE:
log_level_str = NEU_LOG_LEVEL_NOTICE;
break;
case ZLOG_LEVEL_WARN:
log_level_str = NEU_LOG_LEVEL_WARN;
break;
case ZLOG_LEVEL_ERROR:
log_level_str = NEU_LOG_LEVEL_ERROR;
break;
case ZLOG_LEVEL_FATAL:
log_level_str = NEU_LOG_LEVEL_FATAL;
break;
default:
log_level_str = "unknown";
break;
}
char json_response[256];
snprintf(json_response, sizeof(json_response), "{\"level\":\"%s\"}",
log_level_str);
neu_http_ok(aio, json_response);
}
void handle_log_list(nng_aio *aio)
{
NEU_VALIDATE_JWT(aio);
plugins/restful/log_handle.h
+2
View File
@@ -24,6 +24,8 @@
// void handle_get_log(nng_aio *aio);
void handle_log_level(nng_aio *aio);
void handle_global_log_level(nng_aio *aio);
void handle_get_global_log_level(nng_aio *aio);
void handle_log_list(nng_aio *aio);
void handle_log_file(nng_aio *aio);
plugins/restful/rest.c
+1
View File
@@ -34,6 +34,7 @@
#include "handle.h"
#include "normal_handle.h"
#include "otel/otel_manager.h"
#include "parser/neu_json_log.h"
#include "plugin_handle.h"
#include "rest.h"
#include "rw_handle.h"
src/adapter/adapter.c
+19
View File
@@ -1572,6 +1572,25 @@ static int adapter_loop(enum neu_event_io_type type, int fd, void *usr_data)
break;
}
case NEU_REQ_UPDATE_NODE_LOG_LEVEL: {
neu_req_update_node_log_level_t *cmd =
(neu_req_update_node_log_level_t *) &header[1];
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);
adapter->timestamp_lev = tv.tv_sec;
nlog_debug("Node %s log level updated to %d",
neu_plugin_to_plugin_common(adapter->plugin)->name,
cmd->log_level);
neu_msg_free((neu_msg_t *) header);
break;
}
case NEU_REQ_PRGFILE_UPLOAD: {
adapter->module->intf_funs->request(
adapter->plugin, (neu_reqresp_head_t *) header, &header[1]);
src/base/msg_internal.h
+2
View File
@@ -100,6 +100,8 @@ extern "C" {
XX(NEU_REQRESP_NODE_DELETED, neu_reqresp_node_deleted_t) \
XX(NEU_REQ_ADD_DRIVERS, neu_req_driver_array_t) \
XX(NEU_REQ_UPDATE_LOG_LEVEL, neu_req_update_log_level_t) \
XX(NEU_REQ_UPDATE_GLOBAL_LOG_LEVEL, neu_req_update_global_log_level_t) \
XX(NEU_REQ_UPDATE_NODE_LOG_LEVEL, neu_req_update_node_log_level_t) \
XX(NEU_REQ_PRGFILE_UPLOAD, neu_req_prgfile_upload_t) \
XX(NEU_REQ_PRGFILE_PROCESS, neu_req_prgfile_process_t) \
XX(NEU_RESP_PRGFILE_PROCESS, neu_resp_prgfile_process_t) \
src/core/manager.c
+64
View File
@@ -82,6 +82,15 @@ uint16_t neu_manager_get_port()
return port++;
}
int neu_manager_get_global_log_level()
{
extern neu_manager_t *g_manager;
if (g_manager != NULL) {
return g_manager->log_level;
}
return ZLOG_LEVEL_INFO;
}
neu_manager_t *neu_manager_create()
{
int rv = 0;
@@ -1606,6 +1615,61 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
break;
}
case NEU_REQ_UPDATE_GLOBAL_LOG_LEVEL: {
neu_req_update_global_log_level_t *cmd =
(neu_req_update_global_log_level_t *) &header[1];
nlog_info("Setting global log level to %d for core and all nodes",
cmd->log_level);
manager->log_level = cmd->log_level;
nlog_level_change(manager->log_level);
UT_array *nodes = neu_node_manager_get_all(manager->node_manager);
if (nodes != NULL) {
neu_resp_node_info_t *node_info = NULL;
while ((node_info = (neu_resp_node_info_t *) utarray_next(
nodes, node_info)) != NULL) {
neu_reqresp_head_t node_header = { 0 };
neu_req_update_node_log_level_t node_cmd = { 0 };
node_header.type = NEU_REQ_UPDATE_NODE_LOG_LEVEL;
node_header.ctx = NULL;
node_header.otel_trace_type = header->otel_trace_type;
node_header.monitor = false;
strcpy(node_header.sender, "manager");
strcpy(node_header.receiver, node_info->node);
node_cmd.log_level = cmd->log_level;
neu_msg_t *node_msg = neu_msg_new(NEU_REQ_UPDATE_NODE_LOG_LEVEL,
&node_header, &node_cmd);
if (node_msg != NULL) {
struct sockaddr_un addr = neu_node_manager_get_addr(
manager->node_manager, node_info->node);
int ret =
neu_send_msg_to(manager->server_fd, &addr, node_msg);
if (ret != 0) {
nlog_warn("Failed to send global log level update to "
"node %s, ret: %d",
node_info->node, ret);
neu_msg_free(node_msg);
} else {
nlog_debug("Sent global log level update to node %s",
node_info->node);
}
}
}
utarray_free(nodes);
}
neu_resp_error_t e = { .error = NEU_ERR_SUCCESS };
header->type = NEU_RESP_ERROR;
neu_msg_exchange(header);
reply(manager, header, &e);
break;
}
case NEU_REQ_ADD_NODE_EVENT:
case NEU_REQ_DEL_NODE_EVENT:
case NEU_REQ_NODE_CTL_EVENT:
src/core/manager.h
+1
View File
@@ -30,5 +30,6 @@ neu_manager_t *neu_manager_create();
void neu_manager_destroy(neu_manager_t *manager);
uint16_t neu_manager_get_port();
int neu_manager_get_global_log_level();
#endif
src/parser/neu_json_log.c
+50
View File
@@ -27,10 +27,12 @@
#include "json/json.h"
#include "msg.h"
#include "neu_json_log.h"
#include "utils/log.h"
#include "utils/utarray.h"
#include "utils/utextend.h"
#include "utils/zlog.h"
int neu_json_decode_update_log_level_req(
char *buf, neu_json_update_log_level_req_t **result)
@@ -103,6 +105,54 @@ void neu_json_decode_update_log_level_req_free(
}
}
int neu_json_decode_update_global_log_level_req(
char *buf, neu_json_update_global_log_level_req_t **result)
{
int ret = 0;
void *json_obj = neu_json_decode_new(buf);
neu_json_update_global_log_level_req_t *req =
calloc(1, sizeof(neu_json_update_global_log_level_req_t));
if (req == NULL) {
return -1;
}
neu_json_elem_t req_elems[] = { {
.name = "level",
.t = NEU_JSON_STR,
} };
ret = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
req_elems);
if (ret != 0) {
goto decode_fail;
}
req->log_level = req_elems[0].v.val_str;
*result = req;
goto decode_exit;
decode_fail:
free(req);
ret = -1;
decode_exit:
if (json_obj != NULL) {
neu_json_decode_free(json_obj);
}
return ret;
}
void neu_json_decode_update_global_log_level_req_free(
neu_json_update_global_log_level_req_t *req)
{
if (req->log_level != NULL) {
free(req->log_level);
}
if (req != NULL) {
free(req);
}
}
int neu_json_encode_log_list_resp(void *json_object, void *param)
{
int ret = 0;
src/parser/neu_json_log.h
+10
View File
@@ -39,6 +39,10 @@ typedef struct {
bool core;
} neu_json_update_log_level_req_t;
typedef struct {
char *log_level;
} neu_json_update_global_log_level_req_t;
typedef struct {
int64_t page_count;
int n_row;
@@ -55,6 +59,12 @@ void neu_json_decode_update_log_level_req_free(
neu_json_update_log_level_req_t *req);
int neu_json_decode_update_log_level_req(
char *buf, neu_json_update_log_level_req_t **result);
void neu_json_decode_update_global_log_level_req_free(
neu_json_update_global_log_level_req_t *req);
int neu_json_decode_update_global_log_level_req(
char *buf, neu_json_update_global_log_level_req_t **result);
int neu_json_encode_log_list_resp(void *json_object, void *param);
#ifdef __cplusplus