From d4bb33c5732de2e41eea2c93ac71ca7e3af8a2e6 Mon Sep 17 00:00:00 2001 From: ionutrazvanionita Date: Tue, 14 Feb 2017 11:34:58 +0200 Subject: [PATCH] [mi] add mi trace payload as JSON --- mi/mi_trace.c | 70 ++++++++++++++++++++++++++++++++++++++++++++++----- mi/mi_trace.h | 55 ++++++++++++++++++++++++---------------- 2 files changed, 98 insertions(+), 27 deletions(-) diff --git a/mi/mi_trace.c b/mi/mi_trace.c index 3212f2d07e2..01571dec564 100644 --- a/mi/mi_trace.c +++ b/mi/mi_trace.c @@ -31,7 +31,6 @@ #define MI_ID_S "mi" #define MI_TRACE_BUF_SIZE (1 << 10) -#define MAX_RPL_CHARS (1 << 7) #define CORR_BUF_SIZE 64 /* CORR - magic for internally generated correltion id */ @@ -45,7 +44,9 @@ str correlation_value; int correlation_id=-1, correlation_vendor=-1; +#if 0 static char trace_buf[MI_TRACE_BUF_SIZE]; +#endif void try_load_trace_api(void) @@ -67,6 +68,7 @@ void try_load_trace_api(void) mi_message_id = mi_trace_api->get_message_id(MI_ID_S); } +#if 0 #define CHECK_OVERFLOW(_len) \ do { \ if ( _len >= MI_TRACE_BUF_SIZE ) { \ @@ -76,13 +78,39 @@ void try_load_trace_api(void) } while (0); char* build_mi_trace_request( str* cmd, struct mi_root* mi_req, str* backend) +#endif +struct mi_trace_req* build_mi_trace_request( str* cmd, + struct mi_root* mi_req, str* backend) { - int len, new; + int len=0, new=0; struct mi_node* node; if ( !cmd || !backend ) return 0; + /* not intereseted if it doesn't fit */ + snprintf( mi_treq.cmd, MAX_TRACE_FIELD, "%.*s", cmd->len, cmd->s); + snprintf( mi_treq.backend, MAX_TRACE_FIELD, "%.*s", backend->len, backend->s); + + if ( mi_req ) { + node = mi_req->node.kids; + while ( node && + (( new = snprintf( mi_treq.params + len, MAX_TRACE_FIELD - len, + "%.*s", node->value.len, node->value.s) ) + < MAX_TRACE_FIELD - len) ) { + if ( new < 0) { + LM_ERR("snprintf failed!\n"); + return 0; + } + node = node->next; + len += new; + } + } else { + memset( mi_treq.params, 0, MAX_TRACE_FIELD); + } + + return &mi_treq; +#if 0 len = snprintf( trace_buf, MI_TRACE_BUF_SIZE, "(%.*s) %.*s\n", backend->len, backend->s, @@ -105,17 +133,20 @@ char* build_mi_trace_request( str* cmd, struct mi_root* mi_req, str* backend) } } - return trace_buf; +#endif } -char* build_mi_trace_reply( int code, str* reason, str* rpl_msg ) +struct mi_trace_rpl* build_mi_trace_reply( int code, str* reason, str* rpl_msg ) { +#if 0 int len, new; +#endif if ( !reason ) return 0; +#if 0 len = snprintf( trace_buf, MI_TRACE_BUF_SIZE, "(%d:%.*s)\n", code, reason->len, reason->s); @@ -132,6 +163,16 @@ char* build_mi_trace_reply( int code, str* reason, str* rpl_msg ) } return trace_buf; +#endif + snprintf( mi_trpl.code, MAX_TRACE_FIELD, "%d", code); + snprintf( mi_trpl.reason, MAX_TRACE_FIELD, "%.*s", reason->len, reason->s); + if ( rpl_msg ) { + snprintf( mi_trpl.rpl, MAX_TRACE_FIELD, "%.*s", rpl_msg->len, rpl_msg->s); + } else { + memset( mi_trpl.rpl, 0, MAX_TRACE_FIELD); + } + + return &mi_trpl; } char* generate_correlation_id(int* len) @@ -152,11 +193,12 @@ char* generate_correlation_id(int* len) int trace_mi_message(union sockaddr_union* src, union sockaddr_union* dst, - str* body, str* correlation_value, trace_dest trace_dst) + struct mi_trace_param* pld_param, str* correlation_value, trace_dest trace_dst) { /* FIXME is this the case for all mi impelementations?? */ const int proto = IPPROTO_TCP; union sockaddr_union tmp, *to_su, *from_su; + static str fake_body = str_init("fake"); trace_message message; @@ -185,7 +227,7 @@ int trace_mi_message(union sockaddr_union* src, union sockaddr_union* dst, to_su = &tmp; message = mi_trace_api->create_trace_message(from_su, to_su, - proto, body, mi_message_id, trace_dst); + proto, &fake_body, mi_message_id, trace_dst); if (message == NULL) { LM_ERR("failed to create trace message!\n"); return -1; @@ -207,6 +249,22 @@ int trace_mi_message(union sockaddr_union* src, union sockaddr_union* dst, } } + if ( pld_param->type == MI_TRACE_REQ ) { + mi_trace_api->add_trace_payload(message, "command", pld_param->d.req->cmd); + mi_trace_api->add_trace_payload(message, "backend", pld_param->d.req->backend); + if ( pld_param->d.req->params[0] ) { + mi_trace_api->add_trace_payload(message, + "parameters", pld_param->d.req->params); + } + } else { + mi_trace_api->add_trace_payload(message, "code", pld_param->d.rpl->code); + mi_trace_api->add_trace_payload(message, "reason", pld_param->d.rpl->reason); + if ( pld_param->d.rpl->rpl[0] ) { + mi_trace_api->add_trace_payload(message, + "reply", pld_param->d.rpl->rpl); + } + } + if (mi_trace_api->send_message(message, trace_dst, 0) < 0) { LM_ERR("failed to send trace message!\n"); return -1; diff --git a/mi/mi_trace.h b/mi/mi_trace.h index afb443b56e5..9e8287d8407 100644 --- a/mi/mi_trace.h +++ b/mi/mi_trace.h @@ -32,19 +32,41 @@ extern trace_proto_t* mi_trace_api; extern int correlation_id, correlation_vendor; extern str correlation_value; +#define MAX_TRACE_FIELD (1 << 7) + +struct mi_trace_req { + char cmd[MAX_TRACE_FIELD]; + char backend[MAX_TRACE_FIELD]; + char params[MAX_TRACE_FIELD]; +} mi_treq; + +struct mi_trace_rpl { + char code[MAX_TRACE_FIELD]; + char reason[MAX_TRACE_FIELD]; + char rpl[MAX_TRACE_FIELD]; +} mi_trpl; + +enum mi_trace_type { MI_TRACE_REQ, MI_TRACE_RPL}; +struct mi_trace_param { + enum mi_trace_type type; + union { + struct mi_trace_req* req; + struct mi_trace_rpl* rpl; + } d; +} mi_tparam; + void try_load_trace_api(void); int trace_mi_message(union sockaddr_union* src, union sockaddr_union* dst, - str* body, str* correlation_value, trace_dest trace_dst); -char* build_mi_trace_request( str* cmd, struct mi_root* mi_req, str* backend); -char* build_mi_trace_reply( int code, str* reason, str* rpl_msg ); -char* generate_correlation_id(int* len); + struct mi_trace_param* pld_param, str* correlation_value, trace_dest trace_dst); +struct mi_trace_req* build_mi_trace_request( str* cmd, + struct mi_root* mi_req, str* backend); +struct mi_trace_rpl* build_mi_trace_reply( int code, str* reason, str* rpl_msg ); +char* generate_correlation_id(int* len);; int load_correlation_id(void); static inline void mi_trace_reply( union sockaddr_union* src, union sockaddr_union* dst, int code, str* reason, str* message, trace_dest t_dst) { - str trace_buf; - /* trace disabled */ if ( !t_dst ) return; @@ -55,19 +77,15 @@ static inline void mi_trace_reply( union sockaddr_union* src, union sockaddr_uni return; } - trace_buf.s = build_mi_trace_reply( code, reason, message); - if ( !trace_buf.s ) { - LM_ERR("can't build reply buffer!\n"); - return; - } + mi_tparam.d.rpl = build_mi_trace_reply( code, reason, message); + mi_tparam.type = MI_TRACE_RPL; - trace_buf.len = strlen(trace_buf.s); if ( !correlation_value.s ) { LM_ERR("can't find correlation id generated by the request!\n"); return; } - if (trace_mi_message( src, dst, &trace_buf, &correlation_value, t_dst) < 0) { + if (trace_mi_message( src, dst, &mi_tparam, &correlation_value, t_dst) < 0) { LM_ERR("failed to trace mi command reply!\n"); } } @@ -77,18 +95,13 @@ static inline void mi_trace_request( union sockaddr_union* src, union sockaddr_u char* command, int len, struct mi_root* mi_req, str* backend, trace_dest t_dst ) { str comm_s = { command, len }; - str trace_buf; if ( !t_dst || !backend ) return; - trace_buf.s = build_mi_trace_request( &comm_s, mi_req, backend); - if ( !trace_buf.s ) { - LM_ERR("Can't build mi request for tracing!\n"); - return; - } + mi_tparam.d.req = build_mi_trace_request( &comm_s, mi_req, backend); + mi_tparam.type = MI_TRACE_REQ; - trace_buf.len = strlen(trace_buf.s); correlation_value.s = generate_correlation_id(&correlation_value.len); if ( !correlation_value.s ) { @@ -96,7 +109,7 @@ static inline void mi_trace_request( union sockaddr_union* src, union sockaddr_u return; } - if (trace_mi_message( src, dst, &trace_buf, &correlation_value, t_dst) < 0) { + if (trace_mi_message( src, dst, &mi_tparam, &correlation_value, t_dst) < 0) { LM_ERR("failed to trace mi command request!\n"); } }