Skip to content

[Feature] Add QueryDetail to store query statistics. #3744

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
chaoyli merged 8 commits into from
Jun 15, 2020
Merged

[Feature] Add QueryDetail to store query statistics. #3744

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
8 commits
Select commit Hold shift + click to select a range
e0acd0b
[Feature] Add QueryDetail to store query statistics.
Jun 1, 2020
9500aac
Fix unit bug
Jun 10, 2020
4bbd061
Fix the bug
Jun 11, 2020
0e368f5
Fix some metrics interface
Jun 12, 2020
16668cd
Fix bug
Jun 13, 2020
65dd79d
Add docs
Jun 13, 2020
a93a0a5
Add some docs
Jun 15, 2020
393d20d
Add unit test for QueryDetailQueue
Jun 15, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
4 changes: 2 additions & 2 deletions be/src/http/action/stream_load.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -59,10 +59,10 @@

namespace doris {

METRIC_DEFINE_INT_COUNTER(streaming_load_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(streaming_load_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(streaming_load_bytes, MetricUnit::BYTES);
METRIC_DEFINE_INT_COUNTER(streaming_load_duration_ms, MetricUnit::MILLISECONDS);
METRIC_DEFINE_INT_GAUGE(streaming_load_current_processing, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(streaming_load_current_processing, MetricUnit::REQUESTS);

#ifdef BE_TEST
TStreamLoadPutResult k_stream_load_put_result;
Expand Down
4 changes: 2 additions & 2 deletions be/src/runtime/client_cache.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -216,12 +216,12 @@ void ClientCacheHelper::init_metrics(MetricRegistry* metrics, const std::string&
// usage, but ensures that _metrics_enabled is published.
boost::lock_guard<boost::mutex> lock(_lock);

_used_clients.reset(new IntGauge(MetricUnit::NUMBER));
_used_clients.reset(new IntGauge(MetricUnit::NOUNIT));
metrics->register_metric("thrift_used_clients",
MetricLabels().add("name", key_prefix),
_used_clients.get());

_opened_clients.reset(new IntGauge(MetricUnit::NUMBER));
_opened_clients.reset(new IntGauge(MetricUnit::NOUNIT));
metrics->register_metric("thrift_opened_clients",
MetricLabels().add("name", key_prefix),
_opened_clients.get());
Expand Down
8 changes: 4 additions & 4 deletions be/src/runtime/memory/chunk_allocator.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,10 +34,10 @@ namespace doris {

ChunkAllocator* ChunkAllocator::_s_instance = nullptr;

static IntCounter local_core_alloc_count(MetricUnit::NUMBER);
static IntCounter other_core_alloc_count(MetricUnit::NUMBER);
static IntCounter system_alloc_count(MetricUnit::NUMBER);
static IntCounter system_free_count(MetricUnit::NUMBER);
static IntCounter local_core_alloc_count(MetricUnit::NOUNIT);
static IntCounter other_core_alloc_count(MetricUnit::NOUNIT);
static IntCounter system_alloc_count(MetricUnit::NOUNIT);
static IntCounter system_free_count(MetricUnit::NOUNIT);
static IntCounter system_alloc_cost_ns(MetricUnit::NANOSECONDS);
static IntCounter system_free_cost_ns(MetricUnit::NANOSECONDS);

Expand Down
9 changes: 4 additions & 5 deletions be/src/runtime/mysql_result_writer.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -61,11 +61,10 @@ Status MysqlResultWriter::init(RuntimeState* state) {
}

void MysqlResultWriter::_init_profile() {
RuntimeProfile* profile = _parent_profile->create_child("MySQLResultWriter", true, true);
_append_row_batch_timer = ADD_TIMER(profile, "AppendBatchTime");
_convert_tuple_timer = ADD_CHILD_TIMER(profile, "TupleConvertTime", "AppendBatchTime");
_result_send_timer = ADD_CHILD_TIMER(profile, "ResultRendTime", "AppendBatchTime");
_sent_rows_counter = ADD_COUNTER(profile, "NumSentRows", TUnit::UNIT);
_append_row_batch_timer = ADD_TIMER(_parent_profile, "AppendBatchTime");
_convert_tuple_timer = ADD_CHILD_TIMER(_parent_profile, "TupleConvertTime", "AppendBatchTime");
_result_send_timer = ADD_CHILD_TIMER(_parent_profile, "ResultRendTime", "AppendBatchTime");
_sent_rows_counter = ADD_COUNTER(_parent_profile, "NumSentRows", TUnit::UNIT);
}

Status MysqlResultWriter::_add_one_row(TupleRow* row) {
Expand Down
2 changes: 1 addition & 1 deletion be/src/runtime/tmp_file_mgr.cc
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -119,7 +119,7 @@ Status TmpFileMgr::init_custom(
}

DCHECK(metrics != NULL);
_num_active_scratch_dirs_metric.reset(new IntGauge(MetricUnit::NUMBER));
_num_active_scratch_dirs_metric.reset(new IntGauge(MetricUnit::NOUNIT));
metrics->register_metric("active_scratch_dirs", _num_active_scratch_dirs_metric.get());
//_active_scratch_dirs_metric = metrics->register_metric(new SetMetric<std::string>(
// TMP_FILE_MGR_ACTIVE_SCRATCH_DIRS_LIST,
Expand Down
5 changes: 1 addition & 4 deletions be/src/util/doris_metrics.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -34,11 +34,9 @@ DorisMetrics::DorisMetrics() : _name("doris_be"), _hook_name("doris_metrics"), _
REGISTER_DORIS_METRIC(fragment_requests_total);
REGISTER_DORIS_METRIC(fragment_request_duration_us);
REGISTER_DORIS_METRIC(http_requests_total);
REGISTER_DORIS_METRIC(http_request_duration_us);
REGISTER_DORIS_METRIC(http_request_send_bytes);
REGISTER_DORIS_METRIC(query_scan_bytes);
REGISTER_DORIS_METRIC(query_scan_rows);
REGISTER_DORIS_METRIC(ranges_processed_total);

REGISTER_DORIS_METRIC(memtable_flush_total);
REGISTER_DORIS_METRIC(memtable_flush_duration_us);
Expand Down Expand Up @@ -180,7 +178,6 @@ DorisMetrics::DorisMetrics() : _name("doris_be"), _hook_name("doris_metrics"), _
REGISTER_DORIS_METRIC(disk_sync_total);
REGISTER_DORIS_METRIC(blocks_open_reading);
REGISTER_DORIS_METRIC(blocks_open_writing);
REGISTER_DORIS_METRIC(blocks_push_remote_duration_us);
}

void DorisMetrics::initialize(
Expand All @@ -196,7 +193,7 @@ void DorisMetrics::initialize(
_metrics.register_metric("disks_avail_capacity", MetricLabels().add("path", path), gauge);
gauge = disks_data_used_capacity.set_key(path, MetricUnit::BYTES);
_metrics.register_metric("disks_data_used_capacity", MetricLabels().add("path", path), gauge);
gauge = disks_state.set_key(path, MetricUnit::BYTES);
gauge = disks_state.set_key(path, MetricUnit::NOUNIT);
_metrics.register_metric("disks_state", MetricLabels().add("path", path), gauge);
}

Expand Down
170 changes: 83 additions & 87 deletions be/src/util/doris_metrics.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -55,92 +55,90 @@ class IntGaugeMetricsMap {
class DorisMetrics {
public:
// counters
METRIC_DEFINE_INT_COUNTER(fragment_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(fragment_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(fragment_request_duration_us, MetricUnit::MICROSECONDS);
METRIC_DEFINE_INT_COUNTER(http_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(http_request_duration_us, MetricUnit::MICROSECONDS);
METRIC_DEFINE_INT_COUNTER(http_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(http_request_send_bytes, MetricUnit::BYTES);
METRIC_DEFINE_INT_COUNTER(query_scan_bytes, MetricUnit::BYTES);
METRIC_DEFINE_INT_COUNTER(query_scan_rows, MetricUnit::BYTES);
METRIC_DEFINE_INT_COUNTER(ranges_processed_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(push_requests_success_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(push_requests_fail_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(query_scan_rows, MetricUnit::ROWS);
METRIC_DEFINE_INT_COUNTER(push_requests_success_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(push_requests_fail_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(push_request_duration_us, MetricUnit::MICROSECONDS);
METRIC_DEFINE_INT_COUNTER(push_request_write_bytes, MetricUnit::BYTES);
METRIC_DEFINE_INT_COUNTER(push_request_write_rows, MetricUnit::ROWS);
METRIC_DEFINE_INT_COUNTER(create_tablet_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(create_tablet_requests_failed, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(drop_tablet_requests_total, MetricUnit::NUMBER);

METRIC_DEFINE_INT_COUNTER(report_all_tablets_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(report_all_tablets_requests_failed, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(report_tablet_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(report_tablet_requests_failed, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(report_disk_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(report_disk_requests_failed, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(report_task_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(report_task_requests_failed, MetricUnit::NUMBER);

METRIC_DEFINE_INT_COUNTER(schema_change_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(schema_change_requests_failed, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(create_rollup_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(create_rollup_requests_failed, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(storage_migrate_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(delete_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(delete_requests_failed, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(clone_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(clone_requests_failed, MetricUnit::NUMBER);

METRIC_DEFINE_INT_COUNTER(finish_task_requests_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(finish_task_requests_failed, MetricUnit::NUMBER);

METRIC_DEFINE_INT_COUNTER(base_compaction_request_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(base_compaction_request_failed, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(cumulative_compaction_request_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(cumulative_compaction_request_failed, MetricUnit::NUMBER);

METRIC_DEFINE_INT_COUNTER(base_compaction_deltas_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(create_tablet_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(create_tablet_requests_failed, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(drop_tablet_requests_total, MetricUnit::REQUESTS);

METRIC_DEFINE_INT_COUNTER(report_all_tablets_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(report_all_tablets_requests_failed, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(report_tablet_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(report_tablet_requests_failed, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(report_disk_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(report_disk_requests_failed, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(report_task_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(report_task_requests_failed, MetricUnit::REQUESTS);

METRIC_DEFINE_INT_COUNTER(schema_change_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(schema_change_requests_failed, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(create_rollup_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(create_rollup_requests_failed, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(storage_migrate_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(delete_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(delete_requests_failed, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(clone_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(clone_requests_failed, MetricUnit::REQUESTS);

METRIC_DEFINE_INT_COUNTER(finish_task_requests_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(finish_task_requests_failed, MetricUnit::REQUESTS);

METRIC_DEFINE_INT_COUNTER(base_compaction_request_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(base_compaction_request_failed, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(cumulative_compaction_request_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(cumulative_compaction_request_failed, MetricUnit::REQUESTS);

METRIC_DEFINE_INT_COUNTER(base_compaction_deltas_total, MetricUnit::ROWSETS);
METRIC_DEFINE_INT_COUNTER(base_compaction_bytes_total, MetricUnit::BYTES);
METRIC_DEFINE_INT_COUNTER(cumulative_compaction_deltas_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(cumulative_compaction_deltas_total, MetricUnit::ROWSETS);
METRIC_DEFINE_INT_COUNTER(cumulative_compaction_bytes_total, MetricUnit::BYTES);

METRIC_DEFINE_INT_COUNTER(publish_task_request_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(publish_task_failed_total, MetricUnit::NUMBER);

METRIC_DEFINE_INT_COUNTER(meta_write_request_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(meta_write_request_duration_us, MetricUnit::MICROSECONDS);
METRIC_DEFINE_INT_COUNTER(meta_read_request_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(meta_read_request_duration_us, MetricUnit::MICROSECONDS);
METRIC_DEFINE_INT_COUNTER(publish_task_request_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(publish_task_failed_total, MetricUnit::REQUESTS);

METRIC_DEFINE_INT_COUNTER(meta_write_request_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(meta_write_request_duration_us, MetricUnit::MICROSECONDS);
METRIC_DEFINE_INT_COUNTER(meta_read_request_total, MetricUnit::REQUESTS);
METRIC_DEFINE_INT_COUNTER(meta_read_request_duration_us, MetricUnit::MICROSECONDS);

// Counters for segment_v2
// -----------------------
// total number of segments read
METRIC_DEFINE_INT_COUNTER(segment_read_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(segment_read_total, MetricUnit::OPERATIONS);
// total number of rows in queried segments (before index pruning)
METRIC_DEFINE_INT_COUNTER(segment_row_total, MetricUnit::ROWS);
// total number of rows selected by short key index
METRIC_DEFINE_INT_COUNTER(segment_rows_by_short_key, MetricUnit::ROWS);
// total number of rows selected by zone map index
METRIC_DEFINE_INT_COUNTER(segment_rows_read_by_zone_map, MetricUnit::ROWS);

METRIC_DEFINE_INT_COUNTER(txn_begin_request_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(txn_commit_request_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(txn_rollback_request_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(txn_exec_plan_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(txn_begin_request_total, MetricUnit::OPERATIONS);
METRIC_DEFINE_INT_COUNTER(txn_commit_request_total, MetricUnit::OPERATIONS);
METRIC_DEFINE_INT_COUNTER(txn_rollback_request_total, MetricUnit::OPERATIONS);
METRIC_DEFINE_INT_COUNTER(txn_exec_plan_total, MetricUnit::OPERATIONS);
METRIC_DEFINE_INT_COUNTER(stream_receive_bytes_total, MetricUnit::BYTES);
METRIC_DEFINE_INT_COUNTER(stream_load_rows_total, MetricUnit::ROWS);
METRIC_DEFINE_INT_COUNTER(load_rows_total, MetricUnit::ROWS);
METRIC_DEFINE_INT_COUNTER(load_bytes_total, MetricUnit::BYTES);

METRIC_DEFINE_INT_COUNTER(memtable_flush_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(memtable_flush_total, MetricUnit::OPERATIONS);
METRIC_DEFINE_INT_COUNTER(memtable_flush_duration_us, MetricUnit::MICROSECONDS);

// Gauges
METRIC_DEFINE_INT_GAUGE(memory_pool_bytes_total, MetricUnit::BYTES);
METRIC_DEFINE_INT_GAUGE(process_thread_num, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(process_fd_num_used, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(process_fd_num_limit_soft, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(process_fd_num_limit_hard, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(process_thread_num, MetricUnit::NOUNIT);
METRIC_DEFINE_INT_GAUGE(process_fd_num_used, MetricUnit::NOUNIT);
METRIC_DEFINE_INT_GAUGE(process_fd_num_limit_soft, MetricUnit::NOUNIT);
METRIC_DEFINE_INT_GAUGE(process_fd_num_limit_hard, MetricUnit::NOUNIT);
IntGaugeMetricsMap disks_total_capacity;
IntGaugeMetricsMap disks_avail_capacity;
IntGaugeMetricsMap disks_data_used_capacity;
Expand All @@ -149,46 +147,44 @@ class DorisMetrics {
// the max compaction score of all tablets.
// Record base and cumulative scores separately, because
// we need to get the larger of the two.
METRIC_DEFINE_INT_GAUGE(tablet_cumulative_max_compaction_score, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(tablet_base_max_compaction_score, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(tablet_cumulative_max_compaction_score, MetricUnit::NOUNIT);
METRIC_DEFINE_INT_GAUGE(tablet_base_max_compaction_score, MetricUnit::NOUNIT);

// The following metrics will be calculated
// by metric calculator
METRIC_DEFINE_INT_GAUGE(push_request_write_bytes_per_second, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(query_scan_bytes_per_second, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(push_request_write_bytes_per_second, MetricUnit::BYTES);
METRIC_DEFINE_INT_GAUGE(query_scan_bytes_per_second, MetricUnit::BYTES);
METRIC_DEFINE_INT_GAUGE(max_disk_io_util_percent, MetricUnit::PERCENT);
METRIC_DEFINE_INT_GAUGE(max_network_send_bytes_rate, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(max_network_receive_bytes_rate, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(max_network_send_bytes_rate, MetricUnit::BYTES);
METRIC_DEFINE_INT_GAUGE(max_network_receive_bytes_rate, MetricUnit::BYTES);

// Metrics related with BlockManager
METRIC_DEFINE_INT_COUNTER(readable_blocks_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(writable_blocks_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(blocks_created_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(blocks_deleted_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_COUNTER(readable_blocks_total, MetricUnit::BLOCKS);
METRIC_DEFINE_INT_COUNTER(writable_blocks_total, MetricUnit::BLOCKS);
METRIC_DEFINE_INT_COUNTER(blocks_created_total, MetricUnit::OPERATIONS);
METRIC_DEFINE_INT_COUNTER(blocks_deleted_total, MetricUnit::OPERATIONS);
METRIC_DEFINE_INT_COUNTER(bytes_read_total, MetricUnit::BYTES);
METRIC_DEFINE_INT_COUNTER(bytes_written_total, MetricUnit::BYTES);
METRIC_DEFINE_INT_COUNTER(disk_sync_total, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(blocks_open_reading, MetricUnit::NUMBER);
METRIC_DEFINE_INT_GAUGE(blocks_open_writing, MetricUnit::NUMBER);

METRIC_DEFINE_INT_COUNTER(blocks_push_remote_duration_us, MetricUnit::MICROSECONDS);
METRIC_DEFINE_INT_COUNTER(disk_sync_total, MetricUnit::OPERATIONS);
METRIC_DEFINE_INT_GAUGE(blocks_open_reading, MetricUnit::BLOCKS);
METRIC_DEFINE_INT_GAUGE(blocks_open_writing, MetricUnit::BLOCKS);

// Size of some global containers
METRIC_DEFINE_UINT_GAUGE(rowset_count_generated_and_in_use, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(unused_rowsets_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(broker_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(data_stream_receiver_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(fragment_endpoint_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(active_scan_context_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(plan_fragment_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(load_channel_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(result_buffer_block_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(result_block_queue_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(routine_load_task_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(small_file_cache_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(stream_load_pipe_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(brpc_endpoint_stub_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(tablet_writer_count, MetricUnit::NUMBER);
METRIC_DEFINE_UINT_GAUGE(rowset_count_generated_and_in_use, MetricUnit::ROWSETS);
METRIC_DEFINE_UINT_GAUGE(unused_rowsets_count, MetricUnit::ROWSETS);
METRIC_DEFINE_UINT_GAUGE(broker_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(data_stream_receiver_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(fragment_endpoint_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(active_scan_context_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(plan_fragment_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(load_channel_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(result_buffer_block_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(result_block_queue_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(routine_load_task_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(small_file_cache_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(stream_load_pipe_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(brpc_endpoint_stub_count, MetricUnit::NOUNIT);
METRIC_DEFINE_UINT_GAUGE(tablet_writer_count, MetricUnit::NOUNIT);

static DorisMetrics* instance() {
static DorisMetrics instance;
Expand Down
12 changes: 10 additions & 2 deletions be/src/util/metrics.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -59,10 +59,18 @@ const char* unit_name(MetricUnit unit) {
return "bytes";
case MetricUnit::ROWS:
return "rows";
case MetricUnit::NUMBER:
return "number";
case MetricUnit::PERCENT:
return "percent";
case MetricUnit::REQUESTS:
return "requests";
case MetricUnit::OPERATIONS:
return "operations";
case MetricUnit::BLOCKS:
return "blocks";
case MetricUnit::ROWSETS:
return "rowsets";
case MetricUnit::CONNECTIONS:
return "rowsets";
default:
return "nounit";
}
Expand Down
7 changes: 6 additions & 1 deletion be/src/util/metrics.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -54,8 +54,13 @@ enum class MetricUnit {
SECONDS,
BYTES,
ROWS,
NUMBER,
PERCENT,
REQUESTS,
OPERATIONS,
BLOCKS,
ROWSETS,
CONNECTIONS,
PACKETS,
NOUNIT
};

Expand Down
Loading