hcq/oceanbase
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

[FEAT MERGE]Query Interface Enhancement

Browse Source 
Co-authored-by: chinaxing <chen.yack@gmail.com>
This commit is contained in:
obdev
2023-04-28 02:41:45 +00:00
committed by ob-robot
parent d48cc591bd
commit 23b365a0a7
74 changed files with 2611 additions and 330 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/sql/monitor/flt/ob_flt_extra_info.cpp
View File

@ -93,6 +93,9 @@ int FLTControlInfo::serialize(char *buf, const int64_t len, int64_t &pos)
} else if (OB_FAIL(ObProtoTransUtil::store_int8(buf, len, pos,
slow_query_thres_, FLT_SLOW_QUERY_THRES))) {
OB_LOG(WARN,"failed to store extra info id", K(FLT_RECORD_POLICY), K(buf));
} else if (support_show_trace_ && OB_FAIL(ObProtoTransUtil::store_int1(buf, len, pos,
show_trace_enable_, FLT_SHOW_TRACE_ENABLE))) {
OB_LOG(WARN,"failed to store extra info id", K(FLT_SHOW_TRACE_ENABLE), K(buf));
} else {
// fill type and len in the head
int32_t total_len = pos - org_pos - FLT_HEADER_LEN;
@ -157,10 +160,17 @@ int FLTControlInfo::deserialize_field(FullLinkTraceExtraInfoId extra_id, const i
}
break;
}
case FLT_SHOW_TRACE_ENABLE: {
int8_t v = 0;
if (OB_FAIL(ObProtoTransUtil::get_int1(buf, len, pos, v_len, v))) {
OB_LOG(WARN,"failed to resolve flt level", K(ret));
} else {
show_trace_enable_ = static_cast<bool>(v);
}
break;
}
default: {
ret = OB_NOT_SUPPORTED;
LOG_USER_ERROR(OB_NOT_SUPPORTED, "this extra info id");
OB_LOG(WARN,"invalid extra info id", K(extra_id));
// skip
break;
}
}
@ -172,7 +182,8 @@ int FLTControlInfo::get_serialize_size()
FLT_HEADER_LEN + sizeof(sample_pct_) +
FLT_HEADER_LEN + sizeof(int8_t) +
FLT_HEADER_LEN + sizeof(print_sample_pct_) +
FLT_HEADER_LEN + sizeof(slow_query_thres_);
FLT_HEADER_LEN + sizeof(slow_query_thres_) +
(support_show_trace_ ? (FLT_HEADER_LEN + sizeof(show_trace_enable_)) : 0);
}
int FLTSpanInfo::serialize(char *buf, const int64_t len, int64_t &pos)
{
@ -267,9 +278,7 @@ int FLTSpanInfo::deserialize_field(FullLinkTraceExtraInfoId extra_id, const int6
break;
}
default: {
ret = OB_NOT_SUPPORTED;
LOG_USER_ERROR(OB_NOT_SUPPORTED, "this extra info id");
OB_LOG(WARN,"invalid extra info id", K(extra_id));
// skip
break;
}
}
@ -301,9 +310,7 @@ int FLTDrvSpan::deserialize_field(FullLinkTraceExtraInfoId extra_id, const int64
break;
}
default: {
ret = OB_NOT_SUPPORTED;
LOG_USER_ERROR(OB_NOT_SUPPORTED, "this extra info id");
OB_LOG(WARN,"invalid extra info id", K(extra_id));
// skip
break;
}
}
@ -362,9 +369,7 @@ int FLTAppInfo::deserialize_field(FullLinkTraceExtraInfoId extra_id, const int64
break;
}
default: {
ret = OB_NOT_SUPPORTED;
LOG_USER_ERROR(OB_NOT_SUPPORTED, "this extra info id");
OB_LOG(WARN,"invalid extra info id", K(extra_id));
// skip
break;
}
}
@ -434,9 +439,7 @@ int FLTQueryInfo::deserialize_field(FullLinkTraceExtraInfoId extra_id, const int
break;
}
default: {
ret = OB_NOT_SUPPORTED;
LOG_USER_ERROR(OB_NOT_SUPPORTED, "this extra info id");
OB_LOG(WARN,"invalid extra info id", K(extra_id));
// skip
break;
}
}
@ -461,7 +464,7 @@ int FLTShowTrace::deserialize_field(FullLinkTraceExtraInfoId extra_id, const int
int ret = OB_SUCCESS;
switch(extra_id) {
case FLT_SHOW_TRACE_SPAN: {
case FLT_PROXY_SHOW_TRACE_SPAN: {
char* ptr = NULL;
if (OB_FAIL(ObProtoTransUtil::get_str(buf, len, pos, v_len, ptr))) {
OB_LOG(WARN,"failed to resolve flt level", K(ret));
@ -471,9 +474,18 @@ int FLTShowTrace::deserialize_field(FullLinkTraceExtraInfoId extra_id, const int
}
break;
}
case FLT_DRV_SHOW_TRACE_SPAN: {
char* ptr = NULL;
if (OB_FAIL(ObProtoTransUtil::get_str(buf, len, pos, v_len, ptr))) {
OB_LOG(WARN,"failed to resolve flt level", K(ret));
} else {
// do nothing
show_trace_drv_span_.assign(ptr, v_len);
}
break;
}
default: {
ret = OB_NOT_SUPPORTED;
OB_LOG(WARN,"invalid extra info id", K(extra_id));
// skip
break;
}
}

33
src/sql/monitor/flt/ob_flt_extra_info.h
View File

@ -34,6 +34,7 @@ FLT_EXTRA_INFO_DEF(FLT_SAMPLE_PERCENTAGE, 2021, EMySQLFieldType::MYSQL_TYPE_DOUB
FLT_EXTRA_INFO_DEF(FLT_RECORD_POLICY, 2022, EMySQLFieldType::MYSQL_TYPE_TINY)
FLT_EXTRA_INFO_DEF(FLT_PRINT_SAMPLE_PCT, 2023, EMySQLFieldType::MYSQL_TYPE_DOUBLE)
FLT_EXTRA_INFO_DEF(FLT_SLOW_QUERY_THRES, 2024, EMySQLFieldType::MYSQL_TYPE_LONGLONG)
FLT_EXTRA_INFO_DEF(FLT_SHOW_TRACE_ENABLE, 2025, EMySQLFieldType::MYSQL_TYPE_TINY)
// SPAN_INFO
FLT_EXTRA_INFO_DEF(FLT_TRACE_ENABLE, 2030, EMySQLFieldType::MYSQL_TYPE_TINY)
@ -42,8 +43,9 @@ FLT_EXTRA_INFO_DEF(FLT_TRACE_ID, 2032, EMySQLFieldType::MYSQL_TYPE_VAR_STRING)
FLT_EXTRA_INFO_DEF(FLT_REF_TYPE, 2033, EMySQLFieldType::MYSQL_TYPE_TINY)
FLT_EXTRA_INFO_DEF(FLT_SPAN_ID, 2034, EMySQLFieldType::MYSQL_TYPE_VAR_STRING)
//FLT_SHOW_TRACE
FLT_EXTRA_INFO_DEF(FLT_SHOW_TRACE_SPAN,2040,EMySQLFieldType::MYSQL_TYPE_VAR_STRING)
// SHOW_TRACE_SPAN
FLT_EXTRA_INFO_DEF(FLT_DRV_SHOW_TRACE_SPAN,2050,EMySQLFieldType::MYSQL_TYPE_VAR_STRING)
FLT_EXTRA_INFO_DEF(FLT_PROXY_SHOW_TRACE_SPAN,2051,EMySQLFieldType::MYSQL_TYPE_VAR_STRING)
FLT_EXTRA_INFO_DEF(FLT_EXTRA_INFO_END, 65535, EMySQLFieldType::MYSQL_TYPE_NOT_DEFINED)
#endif /* FLT_EXTRA_INFO_DEF */
@ -79,7 +81,7 @@ enum FullLinkTraceExtraInfoType
FLT_TYPE_QUERY_INFO = 2002,
FLT_TYPE_CONTROL_INFO = 2003,
FLT_TYPE_SPAN_INFO = 2004,
FLT_TYPE_SHOW_TRACE = 2005,
FLT_TYPE_SHOW_TRACE_SPAN = 2005,
FLT_EXTRA_TYPE_END = 65535
};
@ -153,12 +155,16 @@ class FLTControlInfo : public FLTExtraInfo
RecordPolicy rp_;
double print_sample_pct_;
int64_t slow_query_thres_;
bool show_trace_enable_;
bool support_show_trace_;
FLTControlInfo() : level_(-1),
sample_pct_(-1),
rp_(MAX_RECORD_POLICY),
print_sample_pct_(-1),
slow_query_thres_(-1) {
slow_query_thres_(-1),
show_trace_enable_(false),
support_show_trace_(false) {
type_ = FLT_TYPE_CONTROL_INFO;
}
~FLTControlInfo() {}
@ -172,12 +178,21 @@ class FLTControlInfo : public FLTExtraInfo
bool is_valid_sys_config() {
return print_sample_pct_ >= 0 && print_sample_pct_ <= 1 && slow_query_thres_ > 0;
}
bool is_equal(const FLTControlInfo &other) {
return level_ == other.level_ &&
sample_pct_ == other.sample_pct_ &&
rp_ == other.rp_ &&
print_sample_pct_ == other.print_sample_pct_ &&
slow_query_thres_ == other.slow_query_thres_ &&
show_trace_enable_ == other.show_trace_enable_;
}
void reset() {
level_ = -1;
sample_pct_ = -1;
rp_ = MAX_RECORD_POLICY;
print_sample_pct_ = -1;
slow_query_thres_ = -1;
show_trace_enable_ = false;
}
inline bool operator==(const FLTControlInfo &other) const {
@ -191,7 +206,7 @@ class FLTControlInfo : public FLTExtraInfo
const int64_t v_len, const char *buf,
const int64_t len, int64_t &pos);
int get_serialize_size();
TO_STRING_KV(K_(level), K_(sample_pct), K_(rp), K_(print_sample_pct), K_(slow_query_thres));
TO_STRING_KV(K_(level), K_(sample_pct), K_(rp), K_(print_sample_pct), K_(slow_query_thres), K_(show_trace_enable), K_(support_show_trace));
};
class FLTSpanInfo : public FLTExtraInfo
@ -297,9 +312,11 @@ class FLTShowTrace : public FLTExtraInfo
{
public:
ObString show_trace_span_;
ObString show_trace_drv_span_;
FLTShowTrace() : show_trace_span_() {
type_ = FLT_TYPE_SHOW_TRACE;
FLTShowTrace() : show_trace_span_(),
show_trace_drv_span_() {
type_ = FLT_TYPE_SHOW_TRACE_SPAN;
}
~FLTShowTrace() {}
@ -309,7 +326,7 @@ class FLTShowTrace : public FLTExtraInfo
const int64_t v_len, const char *buf,
const int64_t len, int64_t &pos);
int get_serialize_size();
TO_STRING_KV(K_(show_trace_span));
TO_STRING_KV(K_(show_trace_span), K_(show_trace_drv_span));
};
}; // end of namespace lib
}; // end of namespace oceanbase

40
src/sql/monitor/flt/ob_flt_span_mgr.cpp
View File

@ -47,7 +47,7 @@ namespace sql
"SqlFltSpanRec",
tenant_id,
INT64_MAX))) {
SERVER_LOG(WARN, "failed to init allocator", K(ret));
SERVER_LOG(WARN, "failed to init allocator", K(ret));
} else {
mem_limit_ = max_mem_size;
tenant_id_ = tenant_id;
@ -104,7 +104,7 @@ namespace sql
}
int ObFLTSpanMgr::record_span(ObFLTSpanData &span_data)
int ObFLTSpanMgr::record_span(ObFLTSpanData &span_data, bool is_formmated_json)
{
int ret = OB_SUCCESS;
if (!inited_) {
@ -120,7 +120,8 @@ namespace sql
+ min(span_data.parent_span_id_.length(), OB_MAX_SPAN_LENGTH)
+ min(span_data.span_name_.length(), OB_MAX_SPAN_LENGTH)
+ min(span_data.tags_.length(), OB_MAX_SPAN_TAG_LENGTH)
+ min(span_data.logs_.length(), OB_MAX_SPAN_TAG_LENGTH);
+ min(span_data.logs_.length(), OB_MAX_SPAN_TAG_LENGTH)
+ (is_formmated_json ? 0:4);
if (NULL == (buf = (char*)allocator_.alloc(total_sz))) {
ret = OB_ALLOCATE_MEMORY_FAILED;
if (REACH_TIME_INTERVAL(100 * 1000)) {
@ -161,16 +162,32 @@ namespace sql
//deep copy tags
if (!span_data.tags_.empty()) {
const int len = min(span_data.tags_.length(), OB_MAX_SPAN_TAG_LENGTH);
MEMCPY(buf + pos, span_data.tags_.ptr(), len);
rec->data_.tags_.assign_ptr(buf + pos, len);
pos += len;
if (is_formmated_json) {
MEMCPY(buf + pos, span_data.tags_.ptr(), len);
rec->data_.tags_.assign_ptr(buf + pos, len);
pos += len;
} else {
buf[pos] = '[';
MEMCPY(buf + pos + 1, span_data.tags_.ptr(), len);
buf[pos + len + 1] = ']';
rec->data_.tags_.assign_ptr(buf + pos, len + 2);
pos += len + 2;
}
}
//deep copy logs_
if (!span_data.logs_.empty()) {
const int len = min(span_data.logs_.length(), OB_MAX_SPAN_TAG_LENGTH);
MEMCPY(buf + pos, span_data.logs_.ptr(), len);
rec->data_.logs_.assign_ptr(buf + pos, len);
pos += len;
if (is_formmated_json) {
MEMCPY(buf + pos, span_data.logs_.ptr(), len);
rec->data_.logs_.assign_ptr(buf + pos, len);
pos += len;
} else {
buf[pos] = '[';
MEMCPY(buf + pos + 1, span_data.logs_.ptr(), len);
buf[pos + len + 1] = ']';
rec->data_.logs_.assign_ptr(buf + pos, len + 2);
pos += len + 2;
}
}
//push into queue
if (OB_SUCC(ret)) {
@ -180,9 +197,6 @@ namespace sql
if (REACH_TIME_INTERVAL(2 * 1000 * 1000)) {
SERVER_LOG(WARN, "push into queue failed", K(ret));
}
if (ret == OB_ENTRY_NOT_EXIST) {
release_old(RELEASE_QUEUE_SIZE);
}
allocator_.free(rec);
rec = NULL;
} else {
@ -200,7 +214,7 @@ namespace sql
// evict old span and release memory
int ObFLTSpanMgr::release_old(int64_t limit)
{
void* span = NULL;
void * span = NULL;
int64_t count = 0;
while(count++ < limit && NULL != (span = queue_.pop())) {
free(span);

18
src/sql/monitor/flt/ob_flt_span_mgr.h
View File

@ -19,13 +19,9 @@
#include "lib/string/ob_string.h"
#include "lib/atomic/ob_atomic.h"
#include "lib/stat/ob_diagnose_info.h"
//#include "observer/mysql/ob_mysql_result_set.h"
#include "share/config/ob_server_config.h"
#include "share/schema/ob_schema_getter_guard.h"
//#include "sql/session/ob_sql_session_info.h"
#include "sql/ob_sql_define.h"
//#include "sql/ob_result_set.h"
#include "observer/mysql/ob_eliminate_task.h"
#include "observer/mysql/ob_ra_queue.h"
using namespace oceanbase::common;
@ -41,7 +37,7 @@ namespace sql
static const char START_TS[] = "start_ts";
static const char END_TS[] = "end_ts";
static const char PARENT_SPAN_ID[] = "parent_id";
class ObFLTSpanMgr;
class ObFLTSpanData {
public:
int64_t tenant_id_;
@ -162,9 +158,10 @@ namespace sql
public:
static const int64_t FLT_SPAN_PAGE_SIZE = (1LL << 21) - ACHUNK_PRESERVE_SIZE; // 2M - 17k
static const int32_t BATCH_RELEASE_COUNT = 1000;
//初始化queue大小为1000w
static const int64_t MAX_QUEUE_SIZE = 100000; //10m
static const int64_t RELEASE_QUEUE_SIZE = 10000; //1w
//初始化queue大小为10w
static const int64_t MAX_QUEUE_SIZE = 100000; //10w
static const int64_t RELEASE_QUEUE_SIZE = 50000; //1w
static const int64_t EVICT_INTERVAL = 1000000; //1s
ObFLTSpanMgr()
: inited_(false), destroyed_(false), request_id_(0), mem_limit_(0),
allocator_(), queue_(),
@ -183,8 +180,9 @@ namespace sql
int64_t get_end_idx() const { return (int64_t)queue_.get_push_idx(); }
uint64_t get_tenant_id() { return tenant_id_; }
int init(uint64_t tenant_id, const int64_t max_mem_size, const int64_t queue_size);
int record_span(ObFLTSpanData &span_data);
int record_span(ObFLTSpanData &span_data, bool is_formmated_json);
int release_old(int64_t limit = BATCH_RELEASE_COUNT); // evict old span and release memory
uint64_t get_size() { return queue_.get_size(); }
void destroy();
static int mtl_init(ObFLTSpanMgr* &span_mgr);
static void mtl_destroy(ObFLTSpanMgr* &span_mgr);
@ -220,13 +218,11 @@ namespace sql
int64_t mem_limit_;
common::ObConcurrentFIFOAllocator allocator_; //alloc mem for span info
common::ObRaQueue queue_; // store span node
//ObEliminateTask task_;
// tenant id of this request manager
uint64_t tenant_id_;
int tg_id_;
};
} // namespace sql
} // namespace oceanbase
#endif

257
src/sql/monitor/flt/ob_flt_utils.cpp
View File

@ -16,41 +16,12 @@
#include "sql/monitor/flt/ob_flt_extra_info.h"
#include "sql/monitor/flt/ob_flt_control_info_mgr.h"
#include "sql/session/ob_sql_session_info.h"
#include "lib/json_type/ob_json_base.h"
namespace oceanbase
{
namespace sql
{
int ObFLTUtils::init_flt_show_trace_env(sql::ObSQLSessionInfo &session) {
int ret = OB_SUCCESS;
// if use trace log, init trace framework
if (session.is_inner()) {
// inner sql will reuse trace framework, do nothing
} else {
if (session.is_use_trace_log()) {
// query level trace
if (session.is_query_trc_granuality()) {
FLT_BEGIN_TRACE();
FLT_SET_TRACE_LEVEL(1);
FLT_SET_AUTO_FLUSH(true);
// transaction level trace
} else {
if (session.is_server_status_in_transaction()) {
// do nothing
} else {
FLT_BEGIN_TRACE();
FLT_SET_TRACE_LEVEL(1);
FLT_SET_AUTO_FLUSH(true);
}
}
} else {
FLT_SET_TRACE_LEVEL(0);
FLT_SET_AUTO_FLUSH(false);
}
}
return ret;
}
int ObFLTUtils::record_flt_last_trace_id(sql::ObSQLSessionInfo &session) {
int ret = OB_SUCCESS;
trace::UUID trc_uuid = OBTRACE->get_trace_id();
@ -185,7 +156,7 @@ namespace sql
}
con.print_sample_pct_ = ((double)(sess.get_tenant_print_sample_ppm()))/1000000;
con.slow_query_thres_ = GCONF.trace_log_slow_query_watermark;
con.show_trace_enable_ = sess.is_use_trace_log();
sess.set_flt_control_info(con);
if (OB_FAIL(con.serialize(buf, size, pos))) {
@ -306,15 +277,13 @@ namespace sql
break;
}
case FLT_TYPE_QUERY_INFO: {
// skip
// this extra info is written by server, and driver/proxy cannot send this to server;
ret = OB_NOT_SUPPORTED;
LOG_WARN("invalid extra_type", K(extra_type), K(ret));
break;
}
case FLT_TYPE_CONTROL_INFO: {
// skip
// this extra info is written by server, and driver/proxy cannot send this to server;
ret = OB_NOT_SUPPORTED;
LOG_WARN("invalid extra_type", K(extra_type), K(ret));
break;
}
case FLT_TYPE_SPAN_INFO: {
@ -334,21 +303,38 @@ namespace sql
}
break;
}
case FLT_TYPE_SHOW_TRACE: {
case FLT_TYPE_SHOW_TRACE_SPAN: {
FLTShowTrace trace;
if (OB_FAIL(trace.deserialize(buf, pos+v_len, pos))) {
LOG_WARN("failed to deserialize full link trace extra info", KP(buf), K(ret), K(pos), K(v_len));
} else {
// add to span
ObString empty_str;
empty_str.reset();
sess.set_last_flt_span_id(empty_str);
if (!trace.show_trace_span_.empty() || !trace.show_trace_drv_span_.empty()) {
ObString empty_str;
empty_str.reset();
sess.set_last_flt_span_id(empty_str);
ObSEArray<ObFLTSpanData, 4> rec_list;
LOG_TRACE("rec show trace drv span",
K(ObString(trace.show_trace_drv_span_.length(), trace.show_trace_drv_span_.ptr())),
KPHEX(trace.show_trace_drv_span_.ptr(), trace.show_trace_drv_span_.length()));
if (OB_FAIL(process_flt_span_rec(trace.show_trace_span_.ptr(),
trace.show_trace_span_.length()))) {
LOG_WARN("failed to generate flt span record from string", K(ret));
} else if (OB_FAIL(process_flt_span_rec(trace.show_trace_drv_span_.ptr(),
trace.show_trace_drv_span_.length()))) {
LOG_WARN("failed to generate flt span record from string", K(ret));
} else {
// do nothing
}
}
}
break;
}
default: {
ret = OB_NOT_SUPPORTED;
LOG_WARN("invalid extra_type", K(extra_type), K(ret));
// skip
pos += v_len;
break;
}
} // switch ends
@ -412,12 +398,20 @@ namespace sql
tid.deserialize(trace_id.ptr(), trace_id.length(), pos);
pos = 0;
sid.deserialize(span_id.ptr(), span_id.length(), pos);
if (sess.is_use_trace_log()) {
sess.set_auto_flush_trace(true);
}
char buf[40];
pos = 0;
tid.tostring(buf, 40, pos);
OBTRACE->init(tid, sid);
FLT_SET_TRACE_LEVEL(sess.get_control_info().level_);
FLT_SET_AUTO_FLUSH(sess.is_auto_flush_trace() || sess.is_use_trace_log());
}
// update trace_id by server self
} else {
LOG_INFO("chestelew cleint not support flt");
// update trace_id in query granularity
if (sess.is_query_trc_granuality()) {
FLT_BEGIN_TRACE();
@ -430,6 +424,9 @@ namespace sql
// do nothing
}
}
if (sess.is_use_trace_log()) {
sess.set_auto_flush_trace(true);
}
FLT_SET_TRACE_LEVEL(sess.get_control_info().level_);
FLT_SET_AUTO_FLUSH(sess.is_auto_flush_trace() || sess.is_use_trace_log());
}
@ -497,6 +494,182 @@ namespace sql
return ret;
}
int ObFLTUtils::process_flt_span_rec(const char *buf, const int64_t len) {
int ret = OB_SUCCESS;
if (len == 0) {
// do nothing
} else {
ObArenaAllocator allocator;
ObIJsonBase *j_tree = NULL;
if (OB_FAIL(ObJsonBaseFactory::get_json_base(&allocator, buf, len,
ObJsonInType::JSON_TREE, ObJsonInType::JSON_TREE, j_tree))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("fail to parse j_text", K(ret), K(ObString(len, buf)));
} else if (j_tree->json_type() != ObJsonNodeType::J_ARRAY) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid json type", K(ret), K(j_tree->json_type()));
} else {
ObIJsonBase *jobject_ptr = NULL;
ObIJsonBase *jval_ptr = NULL;
//ObString key = "str";
for (int64_t i = 0; OB_SUCC(ret) && i < j_tree->element_count(); i++) {
if (OB_FAIL(j_tree->get_array_element(i, jobject_ptr))) {
LOG_WARN("failed to get array element", K(ret), K(i));
} else if (OB_ISNULL(jobject_ptr)) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("fail to get array child dom", K(ret), K(i));
} else if (jobject_ptr->json_type() != ObJsonNodeType::J_OBJECT) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid json type", K(ret), K(jobject_ptr->json_type()));
} else if (OB_FAIL(resolve_flt_span_rec(jobject_ptr, allocator))) {
LOG_WARN("fail to resolve array child dom", K(ret));
} else {
// do nothing
}
}
}
}
return ret;
}
int ObFLTUtils::resolve_flt_span_rec(ObIJsonBase *j_tree, ObArenaAllocator& alloc)
{
int ret = OB_SUCCESS;
ObFLTSpanData data;
if (OB_ISNULL(j_tree) || j_tree->json_type() != ObJsonNodeType::J_OBJECT) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid json type", K(ret), K(j_tree->json_type()));
} else {
const char* keys[] = {"trace_id", "name", "id", "start_ts", "end_ts",
"parent_id", "is_follow", "tags", "logs"};
data.tenant_id_ = MTL_ID();
if (OB_FAIL(set_json_str_val(keys[0], j_tree, data.trace_id_))) {
LOG_WARN("failed to set str val", K(keys[0]), K(ret));
} else if (OB_FAIL(set_json_str_val(keys[1], j_tree, data.span_name_))) {
LOG_WARN("failed to set str val", K(keys[1]), K(ret));
} else if (OB_FAIL(set_json_str_val(keys[2], j_tree, data.span_id_))) {
LOG_WARN("failed to set str val", K(keys[2]), K(ret));
} else if (OB_FAIL(set_json_num_val(keys[3], j_tree, data.start_ts_))) {
LOG_WARN("failed to set int val", K(keys[3]), K(ret));
} else if (OB_FAIL(set_json_num_val(keys[4], j_tree, data.end_ts_))) {
LOG_WARN("failed to set int val", K(keys[4]), K(ret));
} else if (OB_FAIL(set_json_str_val(keys[5], j_tree, data.parent_span_id_))) {
LOG_WARN("failed to set str val", K(keys[5]), K(ret));
} else if (OB_FAIL(set_json_bool_val(keys[6], j_tree, data.ref_type_))) {
LOG_WARN("failed to set bool val", K(keys[6]), K(ret));
} else if (OB_FAIL(set_json_obj_val(keys[7], j_tree, data.tags_, alloc))) {
LOG_WARN("failed to set str val", K(keys[7]), K(ret));
} else if (OB_FAIL(set_json_obj_val(keys[8], j_tree, data.logs_, alloc))) {
LOG_WARN("failed to set str val", K(keys[8]), K(ret));
} else {
// do nothing
}
}
if (OB_SUCC(ret)) {
if (OB_FAIL(get_flt_span_manager()->record_span(data, true))) {
if (OB_SIZE_OVERFLOW == ret || OB_ALLOCATE_MEMORY_FAILED == ret) {
LOG_TRACE("cannot allocate mem for record", K(ret));
ret = OB_SUCCESS;
} else {
if (REACH_TIME_INTERVAL(100 * 1000)) { // in case logging is too frequent
LOG_WARN("failed to record request info in request manager", K(ret));
}
}
}
}
return ret;
}
int ObFLTUtils::set_json_str_val(ObString key, ObIJsonBase *jobject_ptr, ObString& val) {
int ret = OB_SUCCESS;
ObIJsonBase *jstr_ptr = NULL;
if (OB_FAIL(jobject_ptr->get_object_value(key, jstr_ptr))) {
if (ret == OB_SEARCH_NOT_FOUND) {
ret = OB_SUCCESS;
val.reset();
} else {
LOG_WARN("failed to get object element", K(ret), K(key));
}
} else if (OB_ISNULL(jstr_ptr)) {
// skip
} else if (jstr_ptr->json_type() != ObJsonNodeType::J_STRING) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid json type", K(ret), K(jstr_ptr->json_type()));
} else {
val.assign_ptr(const_cast<char *>(jstr_ptr->get_data()), jstr_ptr->get_data_length());
}
return ret;
}
int ObFLTUtils::set_json_obj_val(ObString key, ObIJsonBase *jobject_ptr,
ObString& val, ObArenaAllocator& alloc) {
int ret = OB_SUCCESS;
ObIJsonBase *jo_ptr = NULL;
ObJsonBuffer j_buf(&alloc);
if (OB_FAIL(jobject_ptr->get_object_value(key, jo_ptr))) {
if (ret == OB_SEARCH_NOT_FOUND) {
ret = OB_SUCCESS;
val.reset();
} else {
LOG_WARN("failed to get object element", K(ret), K(key));
}
} else if (OB_ISNULL(jo_ptr)) {
//ret = OB_ERR_NULL_VALUE;
//LOG_WARN("fail to get array child dom", K(ret));
// skip
} else if (jo_ptr->json_type() != ObJsonNodeType::J_OBJECT &&
jo_ptr->json_type() != ObJsonNodeType::J_ARRAY) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid json type", K(ret), K(jo_ptr->json_type()));
} else if (OB_FAIL(jo_ptr->print(j_buf, true, false, 0))) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("fail to convert json to string", K(ret));
} else {
val.assign_ptr(j_buf.ptr(), j_buf.length());
}
return ret;
}
int ObFLTUtils::set_json_num_val(ObString key, ObIJsonBase *jobject_ptr, int64_t& val) {
int ret = OB_SUCCESS;
ObIJsonBase *jint_ptr = NULL;
if (OB_FAIL(jobject_ptr->get_object_value(key, jint_ptr))) {
if (ret == OB_SEARCH_NOT_FOUND) {
ret = OB_SUCCESS;
val = 0;
} else {
LOG_WARN("failed to get object element", K(ret), K(key));
}
} else if (OB_ISNULL(jint_ptr)) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("fail to get array child dom", K(ret));
} else if (jint_ptr->json_type() != ObJsonNodeType::J_UINT) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid json type", K(ret), K(jint_ptr->json_type()));
} else {
val = jint_ptr->get_int();
}
return ret;
}
int ObFLTUtils::set_json_bool_val(ObString key, ObIJsonBase *jobject_ptr, int64_t& val) {
int ret = OB_SUCCESS;
ObIJsonBase *jbool_ptr = NULL;
if (jobject_ptr->get_object_value(key, jbool_ptr)) {
LOG_WARN("failed to get object element", K(ret), K(key));
} else if (OB_ISNULL(jbool_ptr)) {
ret = OB_ERR_NULL_VALUE;
LOG_WARN("fail to get array child dom", K(ret));
} else if (jbool_ptr->json_type() != ObJsonNodeType::J_BOOLEAN) {
ret = OB_INVALID_ARGUMENT;
LOG_WARN("invalid json type", K(ret), K(jbool_ptr->json_type()));
} else {
val = jbool_ptr->get_boolean();
}
return ret;
}
int handle_span_record(ObFLTSpanMgr *flt_span_manager, char* tag_buf, int64_t tag_len, ::oceanbase::trace::ObSpanCtx* span)
{
int ret = OB_SUCCESS;
@ -571,7 +744,7 @@ namespace sql
// record span
if (OB_FAIL(ret)) {
// do nothing
} else if (OB_FAIL(flt_span_manager->record_span(data))) {
} else if (OB_FAIL(flt_span_manager->record_span(data, false))) {
if (OB_SIZE_OVERFLOW == ret || OB_ALLOCATE_MEMORY_FAILED == ret) {
LOG_TRACE("cannot allocate mem for record", K(ret));
ret = OB_SUCCESS;

7
src/sql/monitor/flt/ob_flt_utils.h
View File

@ -74,10 +74,15 @@ namespace sql
static int init_app_info(sql::ObSQLSessionInfo &sess, sql::FLTAppInfo &app_info);
static int init_flt_log_framework(sql::ObSQLSessionInfo &session, bool is_client_support_flt);
static int update_flush_policy_by_control_info(sql::ObSQLSessionInfo &sess);
static int init_flt_show_trace_env(sql::ObSQLSessionInfo &session);
static int record_flt_last_trace_id(sql::ObSQLSessionInfo &session);
static int clean_flt_show_trace_env(sql::ObSQLSessionInfo &session);
static void clean_flt_env(sql::ObSQLSessionInfo &session);
static int process_flt_span_rec(const char *buf, const int64_t len);
static int resolve_flt_span_rec(ObIJsonBase *j_tree, ObArenaAllocator& alloc);
static int set_json_str_val(ObString key, ObIJsonBase *jobject_ptr, ObString& val);
static int set_json_num_val(ObString key, ObIJsonBase *jobject_ptr, int64_t& val);
static int set_json_bool_val(ObString key, ObIJsonBase *jobject_ptr, int64_t& val);
static int set_json_obj_val(ObString key, ObIJsonBase *jobject_ptr, ObString& val, ObArenaAllocator& alloc);
};
} // namespace sql
} // namespace oceanbase