From f374640bc99ac73e22193088e32a5ed54274a671 Mon Sep 17 00:00:00 2001 From: Georgy Moiseev Date: Wed, 25 Jan 2023 18:46:39 +0300 Subject: [PATCH 1/5] api: allow to invoke callbacks before collect Before this patch, any user that wanted to export metrics to their Lua code needed to perform a consecutive call of `metrics.invoke_callbacks` and `metrics.collect`. Now it could be done with a single `collect` call with `invoke_callbacks` option set to `true`. Part of tarantool/tarantool#8192, part of tarantool/tarantool#7725 --- CHANGELOG.md | 1 + doc/monitoring/api_reference.rst | 7 ++++- metrics/init.lua | 9 ++++++- test/metrics_test.lua | 41 +++++++++++++++++++++++++++--- test/tarantool/lj_metrics_test.lua | 3 +-- test/tarantool/spaces_test.lua | 3 +-- test/tarantool/vinyl_test.lua | 3 +-- 7 files changed, 55 insertions(+), 12 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 16bc630e..7234acac 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - Handle to clear psutils metrics +- `invoke_callbacks` option for `metrics.collect()` ### Fixed diff --git a/doc/monitoring/api_reference.rst b/doc/monitoring/api_reference.rst index 452c20bc..27c2f25a 100644 --- a/doc/monitoring/api_reference.rst +++ b/doc/monitoring/api_reference.rst @@ -347,10 +347,14 @@ Metrics functions Note that both label names and values in ``label_pairs`` are treated as strings. -.. function:: collect() +.. function:: collect([opts]) Collect observations from each collector. + :param table opts: table of collect options: + + * ``invoke_callbacks`` -- if ``true``, ``invoke_callbacks()`` is triggerred before actual collect. + .. class:: registry .. method:: unregister(collector) @@ -431,6 +435,7 @@ Metrics functions .. function:: invoke_callbacks() Invoke all registered callbacks. Has to be called before each ``collect()``. + (Since version **0.16.0**, you may use ``collect{invoke_callbacks = true}`` instead.) If you're using one of the default exporters, ``invoke_callbacks()`` will be called by the exporter. diff --git a/metrics/init.lua b/metrics/init.lua index 9e0d42ac..e1aeecc5 100644 --- a/metrics/init.lua +++ b/metrics/init.lua @@ -41,7 +41,14 @@ local function invoke_callbacks() return registry:invoke_callbacks() end -local function collect() +local function collect(opts) + checks({invoke_callbacks = '?boolean'}) + opts = opts or {} + + if opts.invoke_callbacks then + registry:invoke_callbacks() + end + return registry:collect() end diff --git a/test/metrics_test.lua b/test/metrics_test.lua index e8f1969d..1c7ca5f1 100755 --- a/test/metrics_test.lua +++ b/test/metrics_test.lua @@ -128,15 +128,14 @@ g.test_default_metrics_clear = function() metrics.enable_default_metrics() t.assert_equals(#metrics.collect(), 0) - metrics.invoke_callbacks() - t.assert(#metrics.collect() > 0) + t.assert(#metrics.collect{invoke_callbacks = true} > 0) metrics.clear() t.assert_equals(#metrics.collect(), 0) + t.assert_equals(#metrics.collect{invoke_callbacks = true}, 0) metrics.enable_default_metrics() - metrics.invoke_callbacks() - t.assert(#metrics.collect() > 0) + t.assert(#metrics.collect{invoke_callbacks = true} > 0) end g.test_hotreload_remove_callbacks = function() @@ -156,3 +155,37 @@ g.test_hotreload_remove_callbacks = function() t.assert_equals(len_before_hotreload, len_after_hotreload) end + +local collect_invoke_callbacks_cases = { + default = { + args = nil, + value = 0, + }, + ['true'] = { + args = {invoke_callbacks = true}, + value = 1, + }, + ['false'] = { + args = {invoke_callbacks = false}, + value = 0, + }, +} + +for name, case in pairs(collect_invoke_callbacks_cases) do + g['test_collect_invoke_callbacks_' .. name] = function() + local c = metrics.counter('mycounter') + + local callback = function() + c:inc() + end + metrics.register_callback(callback) + + -- Initialize a value in the registry. + -- Otherwise collector would be empty. + c:reset() + + local observations = metrics.collect(case.args) + local obs = utils.find_obs('mycounter', {}, observations) + t.assert_equals(obs.value, case.value) + end +end diff --git a/test/tarantool/lj_metrics_test.lua b/test/tarantool/lj_metrics_test.lua index 69e3c4df..fbe505bf 100755 --- a/test/tarantool/lj_metrics_test.lua +++ b/test/tarantool/lj_metrics_test.lua @@ -19,10 +19,9 @@ g.test_lj_metrics = function() t.skip_if(metrics_available == false, 'metrics are not available') metrics.enable_default_metrics() - metrics.invoke_callbacks() local lj_metrics = {} - for _, v in pairs(metrics.collect()) do + for _, v in pairs(metrics.collect{invoke_callbacks = true}) do if v.metric_name:startswith(LJ_PREFIX) then table.insert(lj_metrics, v.metric_name) end diff --git a/test/tarantool/spaces_test.lua b/test/tarantool/spaces_test.lua index d8bf92d1..fd06f972 100644 --- a/test/tarantool/spaces_test.lua +++ b/test/tarantool/spaces_test.lua @@ -34,8 +34,7 @@ g.after_each(function() end) local function get_space_metrics(metric_name) - metrics.invoke_callbacks() - return fun.iter(metrics.collect()):filter(function(x) + return fun.iter(metrics.collect{invoke_callbacks = true}):filter(function(x) return x.metric_name:find(metric_name) end):map(function(m) return m.label_pairs end):totable() end diff --git a/test/tarantool/vinyl_test.lua b/test/tarantool/vinyl_test.lua index 65cf9b14..e3a89639 100644 --- a/test/tarantool/vinyl_test.lua +++ b/test/tarantool/vinyl_test.lua @@ -22,8 +22,7 @@ g.before_each(function() end) g.test_vinyl_metrics_present = function() - metrics.invoke_callbacks() - local metrics_cnt = fun.iter(metrics.collect()):filter(function(x) + local metrics_cnt = fun.iter(metrics.collect{invoke_callbacks = true}):filter(function(x) return x.metric_name:find('tnt_vinyl') end):length() if utils.is_version_less(_TARANTOOL, '2.8.3') From 47bf59f9915554df998273fbe41ab96c8074db14 Mon Sep 17 00:00:00 2001 From: Georgy Moiseev Date: Wed, 25 Jan 2023 19:40:16 +0300 Subject: [PATCH 2/5] api: metainfo for collectors Allow to add arbitrary table metainfo for collectors. Set to empty table by default. Part of tarantool/tarantool#8192, part of tarantool/tarantool#7725 --- CHANGELOG.md | 1 + doc/monitoring/api_reference.rst | 13 +++++++++---- metrics/collectors/histogram.lua | 11 ++++++----- metrics/collectors/shared.lua | 5 ++++- metrics/collectors/summary.lua | 9 +++++---- metrics/init.lua | 24 ++++++++++++------------ metrics/utils.lua | 8 ++++---- test/collectors/counter_test.lua | 13 +++++++++++++ test/collectors/gauge_test.lua | 12 ++++++++++++ test/collectors/histogram_test.lua | 19 +++++++++++++++++++ test/collectors/shared_test.lua | 14 ++++++++++++++ test/collectors/summary_test.lua | 17 +++++++++++++++++ 12 files changed, 116 insertions(+), 30 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 7234acac..3974b2f2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Handle to clear psutils metrics - `invoke_callbacks` option for `metrics.collect()` +- Ability to set metainfo for collectors ### Fixed diff --git a/doc/monitoring/api_reference.rst b/doc/monitoring/api_reference.rst index 27c2f25a..631da599 100644 --- a/doc/monitoring/api_reference.rst +++ b/doc/monitoring/api_reference.rst @@ -24,12 +24,13 @@ A collector represents one or more observations that change over time. counter ~~~~~~~ -.. function:: counter(name [, help]) +.. function:: counter(name [, help, metainfo]) Register a new counter. :param string name: collector name. Must be unique. :param string help: collector description. + :param table metainfo: collector metainfo. :return: A counter object. :rtype: counter_obj @@ -85,12 +86,13 @@ counter gauge ~~~~~ -.. function:: gauge(name [, help]) +.. function:: gauge(name [, help, metainfo]) Register a new gauge. :param string name: collector name. Must be unique. :param string help: collector description. + :param table metainfo: collector metainfo. :return: A gauge object. @@ -127,7 +129,7 @@ gauge histogram ~~~~~~~~~ -.. function:: histogram(name [, help, buckets]) +.. function:: histogram(name [, help, buckets, metainfo]) Register a new histogram. @@ -136,6 +138,7 @@ histogram :param table buckets: histogram buckets (an array of sorted positive numbers). The infinity bucket (``INF``) is appended automatically. Default: ``{.005, .01, .025, .05, .075, .1, .25, .5, .75, 1.0, 2.5, 5.0, 7.5, 10.0, INF}``. + :param table metainfo: collector metainfo. :return: A histogram object. @@ -184,7 +187,7 @@ histogram summary ~~~~~~~ -.. function:: summary(name [, help, objectives, params]) +.. function:: summary(name [, help, objectives, params, metainfo]) Register a new summary. Quantile computation is based on the `"Effective computation of biased quantiles over data streams" `_ @@ -217,6 +220,8 @@ summary and how smooth the time window moves. Default value: ``{max_age_time = math.huge, age_buckets_count = 1}``. + :param table metainfo: collector metainfo. + :return: A summary object. :rtype: summary_obj diff --git a/metrics/collectors/histogram.lua b/metrics/collectors/histogram.lua index b1d496a0..2e4b7575 100644 --- a/metrics/collectors/histogram.lua +++ b/metrics/collectors/histogram.lua @@ -18,8 +18,9 @@ function Histogram.check_buckets(buckets) return true end -function Histogram:new(name, help, buckets) - local obj = Shared.new(self, name, help) +function Histogram:new(name, help, buckets, metainfo) + metainfo = table.copy(metainfo) or {} + local obj = Shared.new(self, name, help, metainfo) obj.buckets = buckets or DEFAULT_BUCKETS table.sort(obj.buckets) @@ -27,9 +28,9 @@ function Histogram:new(name, help, buckets) obj.buckets[#obj.buckets+1] = INF end - obj.count_collector = Counter:new(name .. '_count', help) - obj.sum_collector = Counter:new(name .. '_sum', help) - obj.bucket_collector = Counter:new(name .. '_bucket', help) + obj.count_collector = Counter:new(name .. '_count', help, metainfo) + obj.sum_collector = Counter:new(name .. '_sum', help, metainfo) + obj.bucket_collector = Counter:new(name .. '_bucket', help, metainfo) return obj end diff --git a/metrics/collectors/shared.lua b/metrics/collectors/shared.lua index 81f08b09..2cb195b4 100644 --- a/metrics/collectors/shared.lua +++ b/metrics/collectors/shared.lua @@ -24,7 +24,9 @@ function Shared:new_class(kind, method_names) return setmetatable(class, {__index = methods}) end -function Shared:new(name, help) +function Shared:new(name, help, metainfo) + metainfo = table.copy(metainfo) or {} + if not name then error("Name should be set for %s") end @@ -33,6 +35,7 @@ function Shared:new(name, help) help = help or "", observations = {}, label_pairs = {}, + metainfo = metainfo, }, self) end diff --git a/metrics/collectors/summary.lua b/metrics/collectors/summary.lua index 03b58757..30d37f75 100644 --- a/metrics/collectors/summary.lua +++ b/metrics/collectors/summary.lua @@ -6,12 +6,13 @@ local fiber = require('fiber') local Summary = Shared:new_class('summary', {'observe_latency'}) -function Summary:new(name, help, objectives, params) +function Summary:new(name, help, objectives, params, metainfo) params = params or {} - local obj = Shared.new(self, name, help) + metainfo = table.copy(metainfo) or {} + local obj = Shared.new(self, name, help, metainfo) - obj.count_collector = Counter:new(name .. '_count', help) - obj.sum_collector = Counter:new(name .. '_sum', help) + obj.count_collector = Counter:new(name .. '_count', help, metainfo) + obj.sum_collector = Counter:new(name .. '_sum', help, metainfo) obj.objectives = objectives obj.max_age_time = params.max_age_time obj.age_buckets_count = params.age_buckets_count or 1 diff --git a/metrics/init.lua b/metrics/init.lua index e1aeecc5..e44f1877 100644 --- a/metrics/init.lua +++ b/metrics/init.lua @@ -56,32 +56,32 @@ local function clear() registry:clear() end -local function counter(name, help) - checks('string', '?string') +local function counter(name, help, metainfo) + checks('string', '?string', '?table') - return registry:find_or_create(Counter, name, help) + return registry:find_or_create(Counter, name, help, metainfo) end -local function gauge(name, help) - checks('string', '?string') +local function gauge(name, help, metainfo) + checks('string', '?string', '?table') - return registry:find_or_create(Gauge, name, help) + return registry:find_or_create(Gauge, name, help, metainfo) end -local function histogram(name, help, buckets) - checks('string', '?string', '?table') +local function histogram(name, help, buckets, metainfo) + checks('string', '?string', '?table', '?table') if buckets ~= nil and not Histogram.check_buckets(buckets) then error('Invalid value for buckets') end - return registry:find_or_create(Histogram, name, help, buckets) + return registry:find_or_create(Histogram, name, help, buckets, metainfo) end -local function summary(name, help, objectives, params) +local function summary(name, help, objectives, params, metainfo) checks('string', '?string', '?table', { age_buckets_count = '?number', max_age_time = '?number', - }) + }, '?table') if objectives ~= nil and not Summary.check_quantiles(objectives) then error('Invalid value for objectives') end @@ -98,7 +98,7 @@ local function summary(name, help, objectives, params) error('Age buckets count and max age must be present only together') end - return registry:find_or_create(Summary, name, help, objectives, params) + return registry:find_or_create(Summary, name, help, objectives, params, metainfo) end local function set_global_labels(label_pairs) diff --git a/metrics/utils.lua b/metrics/utils.lua index 2353a83c..18335626 100644 --- a/metrics/utils.lua +++ b/metrics/utils.lua @@ -3,16 +3,16 @@ local metrics = require('metrics') local TNT_PREFIX = 'tnt_' local utils = {} -function utils.set_gauge(name, description, value, labels, prefix) +function utils.set_gauge(name, description, value, labels, prefix, metainfo) prefix = prefix or TNT_PREFIX - local gauge = metrics.gauge(prefix .. name, description) + local gauge = metrics.gauge(prefix .. name, description, metainfo) gauge:set(value, labels or {}) return gauge end -function utils.set_counter(name, description, value, labels, prefix) +function utils.set_counter(name, description, value, labels, prefix, metainfo) prefix = prefix or TNT_PREFIX - local counter = metrics.counter(prefix .. name, description) + local counter = metrics.counter(prefix .. name, description, metainfo) counter:reset(labels or {}) counter:inc(value, labels or {}) return counter diff --git a/test/collectors/counter_test.lua b/test/collectors/counter_test.lua index 1c6fda13..9bd77403 100644 --- a/test/collectors/counter_test.lua +++ b/test/collectors/counter_test.lua @@ -90,3 +90,16 @@ g.test_insert_non_number = function() local c = metrics.counter('cnt') t.assert_error_msg_contains('Counter increment should be a number', c.inc, c, true) end + +g.test_metainfo = function() + local metainfo = {my_useful_info = 'here'} + local c = metrics.counter('cnt', nil, metainfo) + t.assert_equals(c.metainfo, metainfo) +end + +g.test_metainfo_immutable = function() + local metainfo = {my_useful_info = 'here'} + local c = metrics.counter('cnt', nil, metainfo) + metainfo['my_useful_info'] = 'there' + t.assert_equals(c.metainfo, {my_useful_info = 'here'}) +end diff --git a/test/collectors/gauge_test.lua b/test/collectors/gauge_test.lua index 0748ca0e..e089ae31 100644 --- a/test/collectors/gauge_test.lua +++ b/test/collectors/gauge_test.lua @@ -78,3 +78,15 @@ g.test_inc_non_number = function() t.assert_error_msg_contains('Collector set value should be a number', c.set, c, true) end +g.test_metainfo = function() + local metainfo = {my_useful_info = 'here'} + local c = metrics.gauge('gauge', nil, metainfo) + t.assert_equals(c.metainfo, metainfo) +end + +g.test_metainfo_immutable = function() + local metainfo = {my_useful_info = 'here'} + local c = metrics.gauge('gauge', nil, metainfo) + metainfo['my_useful_info'] = 'there' + t.assert_equals(c.metainfo, {my_useful_info = 'here'}) +end diff --git a/test/collectors/histogram_test.lua b/test/collectors/histogram_test.lua index ac0bffdb..d765ec13 100644 --- a/test/collectors/histogram_test.lua +++ b/test/collectors/histogram_test.lua @@ -97,3 +97,22 @@ g.test_insert_non_number = function() t.assert_error_msg_contains('Histogram observation should be a number', h.observe, h, true) end + +g.test_metainfo = function() + local metainfo = {my_useful_info = 'here'} + local h = metrics.histogram('hist', 'some histogram', {2, 4}, metainfo) + t.assert_equals(h.metainfo, metainfo) + t.assert_equals(h.sum_collector.metainfo, metainfo) + t.assert_equals(h.count_collector.metainfo, metainfo) + t.assert_equals(h.bucket_collector.metainfo, metainfo) +end + +g.test_metainfo_immutable = function() + local metainfo = {my_useful_info = 'here'} + local h = metrics.histogram('hist', 'some histogram', {2, 4}, metainfo) + metainfo['my_useful_info'] = 'there' + t.assert_equals(h.metainfo, {my_useful_info = 'here'}) + t.assert_equals(h.sum_collector.metainfo, {my_useful_info = 'here'}) + t.assert_equals(h.count_collector.metainfo, {my_useful_info = 'here'}) + t.assert_equals(h.bucket_collector.metainfo, {my_useful_info = 'here'}) +end diff --git a/test/collectors/shared_test.lua b/test/collectors/shared_test.lua index cd041033..e76c02d2 100644 --- a/test/collectors/shared_test.lua +++ b/test/collectors/shared_test.lua @@ -30,3 +30,17 @@ g.test_remove_metric_by_label = function() {'test', 1, {a = 1, b = 2}}, }) end + +g.test_metainfo = function() + local metainfo = {my_useful_info = 'here'} + local c = Shared:new('collector', nil, metainfo) + t.assert_equals(c.metainfo, metainfo) +end + + +g.test_metainfo_immutable = function() + local metainfo = {my_useful_info = 'here'} + local c = Shared:new('collector', nil, metainfo) + metainfo['my_useful_info'] = 'there' + t.assert_equals(c.metainfo, {my_useful_info = 'here'}) +end diff --git a/test/collectors/summary_test.lua b/test/collectors/summary_test.lua index 6d065b41..389db0e1 100644 --- a/test/collectors/summary_test.lua +++ b/test/collectors/summary_test.lua @@ -237,3 +237,20 @@ g.test_insert_non_number = function() t.assert_error_msg_contains('Summary observation should be a number', s.observe, s, true) end + +g.test_metainfo = function() + local metainfo = {my_useful_info = 'here'} + local c = Summary:new('collector', nil, nil, nil, metainfo) + t.assert_equals(c.metainfo, metainfo) + t.assert_equals(c.sum_collector.metainfo, metainfo) + t.assert_equals(c.count_collector.metainfo, metainfo) +end + +g.test_metainfo_immutable = function() + local metainfo = {my_useful_info = 'here'} + local c = Summary:new('collector', nil, nil, nil, metainfo) + metainfo['my_useful_info'] = 'there' + t.assert_equals(c.metainfo, {my_useful_info = 'here'}) + t.assert_equals(c.sum_collector.metainfo, {my_useful_info = 'here'}) + t.assert_equals(c.count_collector.metainfo, {my_useful_info = 'here'}) +end From cdcf3276b6e2074e2777a56f40d39685fb59944c Mon Sep 17 00:00:00 2001 From: Georgy Moiseev Date: Wed, 25 Jan 2023 20:17:19 +0300 Subject: [PATCH 3/5] api: way to distinct default metrics Set metainfo `default` field to `true` for all metric collectors, created with `enable_default_metrics()` callbacks and psutils `update()` callback. For now, default HTTP middleware collector does not have `default = true` metainfo, but it can be changed later. It is not prohibited for user to set `default` metainfo for their custom metrics. Part of tarantool/tarantool#8192, part of tarantool/tarantool#7725 --- CHANGELOG.md | 2 + doc/monitoring/api_reference.rst | 3 ++ metrics/cartridge/failover.lua | 5 +- metrics/cartridge/issues.lua | 6 ++- metrics/psutils/cpu.lua | 9 ++-- metrics/tarantool/clock.lua | 6 ++- metrics/tarantool/cpu.lua | 6 ++- metrics/tarantool/event_loop.lua | 9 ++-- metrics/tarantool/fibers.lua | 12 +++-- metrics/tarantool/info.lua | 45 ++++++++++-------- metrics/tarantool/luajit.lua | 45 ++++++++++-------- metrics/tarantool/memory.lua | 3 +- metrics/tarantool/memtx.lua | 54 +++++++++++----------- metrics/tarantool/network.lua | 53 +++++++++++++--------- metrics/tarantool/operations.lua | 3 +- metrics/tarantool/replicas.lua | 7 ++- metrics/tarantool/runtime.lua | 3 +- metrics/tarantool/slab.lua | 6 ++- metrics/tarantool/spaces.lua | 15 ++++-- metrics/tarantool/system.lua | 3 +- metrics/tarantool/vinyl.lua | 58 ++++++++++++++---------- test/metrics_test.lua | 10 ++++ test/psutils_linux_thread_clean_test.lua | 9 ++++ 23 files changed, 232 insertions(+), 140 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3974b2f2..0b98e9d0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -11,6 +11,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Handle to clear psutils metrics - `invoke_callbacks` option for `metrics.collect()` - Ability to set metainfo for collectors +- Set `metainfo.default` to `true` for all collectors + from `enable_default_metrics()` and psutils collectors ### Fixed diff --git a/doc/monitoring/api_reference.rst b/doc/monitoring/api_reference.rst index 631da599..9bdceb54 100644 --- a/doc/monitoring/api_reference.rst +++ b/doc/monitoring/api_reference.rst @@ -333,6 +333,7 @@ Metrics functions * ``event_loop`` See :ref:`metrics reference ` for details. + All metric collectors from the collection have ``metainfo.default = true``. .. function:: set_global_labels(label_pairs) @@ -615,6 +616,8 @@ To enable CPU metrics, first register a callback function: sum by (thread_name) (idelta(tnt_cpu_thread[$__interval])) / scalar(idelta(tnt_cpu_total[$__interval]) / tnt_cpu_count) +All psutils metric collectors have ``metainfo.default = true``. + To clear CPU metrics when you don't need them anymore, remove the callback and clear the collectors with a method: .. code-block:: lua diff --git a/metrics/cartridge/failover.lua b/metrics/cartridge/failover.lua index 8b4e5945..28de70a3 100644 --- a/metrics/cartridge/failover.lua +++ b/metrics/cartridge/failover.lua @@ -18,7 +18,10 @@ local function update() utils.set_counter( 'cartridge_failover_trigger_total', 'Count of Cartridge Failover triggers', - trigger_cnt + trigger_cnt, + nil, + nil, + {default = true} ) end end diff --git a/metrics/cartridge/issues.lua b/metrics/cartridge/issues.lua index 7b5318b2..1c9207ee 100644 --- a/metrics/cartridge/issues.lua +++ b/metrics/cartridge/issues.lua @@ -21,13 +21,15 @@ local function update() for _, level in ipairs(levels) do local len = fun.iter(issues):filter(function(x) return x.level == level end):length() collectors_list.cartridge_issues = - utils.set_gauge('cartridge_issues', 'Tarantool Cartridge issues', len, {level = level}) + utils.set_gauge('cartridge_issues', 'Tarantool Cartridge issues', + len, {level = level}, nil, {default = true}) end local global_issues_cnt = rawget(_G, '__cartridge_issues_cnt') if global_issues_cnt ~= nil then collectors_list.global_issues = - utils.set_gauge('cartridge_cluster_issues', 'Tarantool Cartridge cluster issues', global_issues_cnt) + utils.set_gauge('cartridge_cluster_issues', 'Tarantool Cartridge cluster issues', + global_issues_cnt, nil, nil, {default = true}) end end diff --git a/metrics/psutils/cpu.lua b/metrics/psutils/cpu.lua index 01d2bb9f..39f8d88c 100644 --- a/metrics/psutils/cpu.lua +++ b/metrics/psutils/cpu.lua @@ -14,9 +14,10 @@ local threads = {} local function update_cpu_metrics() collectors_list.cpu_number = utils.set_gauge('cpu_number', 'The number of processors', - psutils.get_cpu_count()) + psutils.get_cpu_count(), nil, nil, {default = true}) - collectors_list.cpu_time = utils.set_gauge('cpu_time', 'Host CPU time', psutils.get_cpu_time()) + collectors_list.cpu_time = utils.set_gauge('cpu_time', 'Host CPU time', + psutils.get_cpu_time(), nil, nil, {default = true}) local new_threads = {} for _, thread_info in ipairs(psutils.get_process_cpu_time()) do @@ -29,12 +30,12 @@ local function update_cpu_metrics() local utime_labels = table.copy(labels) utime_labels.kind = 'user' collectors_list.cpu_thread = utils.set_gauge('cpu_thread', 'Tarantool thread cpu time', - thread_info.utime, utime_labels) + thread_info.utime, utime_labels, nil, {default = true}) local stime_labels = table.copy(labels) stime_labels.kind = 'system' collectors_list.cpu_thread = utils.set_gauge('cpu_thread', 'Tarantool thread cpu time', - thread_info.stime, stime_labels) + thread_info.stime, stime_labels, nil, {default = true}) threads[thread_info.pid] = nil new_threads[thread_info.pid] = labels diff --git a/metrics/tarantool/clock.lua b/metrics/tarantool/clock.lua index b0f72e2e..078d8e7d 100644 --- a/metrics/tarantool/clock.lua +++ b/metrics/tarantool/clock.lua @@ -25,8 +25,10 @@ local function update_clock_metrics() end end - collectors_list.clock_delta = utils.set_gauge('clock_delta', 'Clock difference', min_delta * 1e-6, {delta = 'min'}) - collectors_list.clock_delta = utils.set_gauge('clock_delta', 'Clock difference', max_delta * 1e-6, {delta = 'max'}) + collectors_list.clock_delta = utils.set_gauge('clock_delta', 'Clock difference', + min_delta * 1e-6, {delta = 'min'}, nil, {default = true}) + collectors_list.clock_delta = utils.set_gauge('clock_delta', 'Clock difference', + max_delta * 1e-6, {delta = 'max'}, nil, {default = true}) end return { diff --git a/metrics/tarantool/cpu.lua b/metrics/tarantool/cpu.lua index f094be67..8286790c 100644 --- a/metrics/tarantool/cpu.lua +++ b/metrics/tarantool/cpu.lua @@ -70,8 +70,10 @@ end local function update_info_metrics() local cpu_time = ss_get_rusage() if cpu_time then - collectors_list.cpu_user_time = utils.set_gauge('cpu_user_time', 'CPU user time usage', cpu_time.ru_utime) - collectors_list.cpu_system_time = utils.set_gauge('cpu_system_time', 'CPU system time usage', cpu_time.ru_stime) + collectors_list.cpu_user_time = utils.set_gauge('cpu_user_time', 'CPU user time usage', + cpu_time.ru_utime, nil, nil, {default = true}) + collectors_list.cpu_system_time = utils.set_gauge('cpu_system_time', 'CPU system time usage', + cpu_time.ru_stime, nil, nil, {default = true}) end end diff --git a/metrics/tarantool/event_loop.lua b/metrics/tarantool/event_loop.lua index ed6d3998..7baa79af 100644 --- a/metrics/tarantool/event_loop.lua +++ b/metrics/tarantool/event_loop.lua @@ -42,9 +42,12 @@ end local function update_info_metrics() local ev_once_time, ev_prolog, ev_epilog = evloop_time() - collectors_list.ev_loop_time = utils.set_gauge('ev_loop_time', 'Event loop time (ms)', ev_once_time) - collectors_list.ev_prolog_time = utils.set_gauge('ev_loop_prolog_time', 'Event loop prolog time (ms)', ev_prolog) - collectors_list.ev_epilog_time = utils.set_gauge('ev_loop_epilog_time', 'Event loop epilog time (ms)', ev_epilog) + collectors_list.ev_loop_time = utils.set_gauge('ev_loop_time', 'Event loop time (ms)', + ev_once_time, nil, nil, {default = true}) + collectors_list.ev_prolog_time = utils.set_gauge('ev_loop_prolog_time', 'Event loop prolog time (ms)', + ev_prolog, nil, nil, {default = true}) + collectors_list.ev_epilog_time = utils.set_gauge('ev_loop_epilog_time', 'Event loop epilog time (ms)', + ev_epilog, nil, nil, {default = true}) end return { diff --git a/metrics/tarantool/fibers.lua b/metrics/tarantool/fibers.lua index d959abc3..78ee72cd 100644 --- a/metrics/tarantool/fibers.lua +++ b/metrics/tarantool/fibers.lua @@ -17,10 +17,14 @@ local function update_fibers_metrics() fused = fused + f.memory.used end - collectors_list.fiber_amount = utils.set_gauge('fiber_amount', 'Amount of fibers', fibers) - collectors_list.fiber_csw = utils.set_gauge('fiber_csw', 'Fibers csw', csws) - collectors_list.fiber_memalloc = utils.set_gauge('fiber_memalloc', 'Fibers memalloc', falloc) - collectors_list.fiber_memused = utils.set_gauge('fiber_memused', 'Fibers memused', fused) + collectors_list.fiber_amount = utils.set_gauge('fiber_amount', 'Amount of fibers', + fibers, nil, nil, {default = true}) + collectors_list.fiber_csw = utils.set_gauge('fiber_csw', 'Fibers csw', + csws, nil, nil, {default = true}) + collectors_list.fiber_memalloc = utils.set_gauge('fiber_memalloc', 'Fibers memalloc', + falloc, nil, nil, {default = true}) + collectors_list.fiber_memused = utils.set_gauge('fiber_memused', 'Fibers memused', + fused, nil, nil, {default = true}) end return { diff --git a/metrics/tarantool/info.lua b/metrics/tarantool/info.lua index efe60731..3190cffa 100644 --- a/metrics/tarantool/info.lua +++ b/metrics/tarantool/info.lua @@ -20,66 +20,75 @@ local function update_info_metrics() local info = box.info() - collectors_list.info_lsn = utils.set_gauge('info_lsn', 'Tarantool lsn', info.lsn) - collectors_list.info_uptime = utils.set_gauge('info_uptime', 'Tarantool uptime', info.uptime) + collectors_list.info_lsn = utils.set_gauge('info_lsn', 'Tarantool lsn', + info.lsn, nil, nil, {default = true}) + collectors_list.info_uptime = utils.set_gauge('info_uptime', 'Tarantool uptime', + info.uptime, nil, nil, {default = true}) for k, v in pairs(info.vclock) do - collectors_list.info_vclock = utils.set_gauge('info_vclock', 'VClock', v, {id = k}) + collectors_list.info_vclock = utils.set_gauge('info_vclock', 'VClock', + v, {id = k}, nil, {default = true}) end for k, v in pairs(info.replication) do if v.upstream ~= nil then collectors_list.replication_lag = - utils.set_gauge('replication_lag', 'Replication lag', v.upstream.lag, {stream = 'upstream', id = k}) + utils.set_gauge('replication_lag', 'Replication lag', + v.upstream.lag, {stream = 'upstream', id = k}, nil, {default = true}) collectors_list.replication_status = - utils.set_gauge('replication_status', 'Replication status', v.upstream.status == 'follow' and 1 or 0, - {stream = 'upstream', id = k}) + utils.set_gauge('replication_status', 'Replication status', + v.upstream.status == 'follow' and 1 or 0, {stream = 'upstream', id = k}, + nil, {default = true}) end if v.downstream ~= nil then collectors_list.replication_lag = - utils.set_gauge('replication_lag', 'Replication lag', v.downstream.lag, {stream = 'downstream', id = k}) + utils.set_gauge('replication_lag', 'Replication lag', + v.downstream.lag, {stream = 'downstream', id = k}, + nil, {default = true}) collectors_list.replication_status = - utils.set_gauge('replication_status', 'Replication status', v.downstream.status == 'follow' and 1 or 0, - {stream = 'downstream', id = k}) + utils.set_gauge('replication_status', 'Replication status', + v.downstream.status == 'follow' and 1 or 0, {stream = 'downstream', id = k}, + nil, {default = true}) end end - collectors_list.read_only = utils.set_gauge('read_only', 'Is instance read only', read_only_status[info.ro]) + collectors_list.read_only = utils.set_gauge('read_only', 'Is instance read only', + read_only_status[info.ro], nil, nil, {default = true}) if info.synchro ~= nil then collectors_list.synchro_queue_owner = utils.set_gauge('synchro_queue_owner', 'Synchro queue owner', - info.synchro.queue.owner) + info.synchro.queue.owner, nil, nil, {default = true}) collectors_list.synchro_queue_term = utils.set_gauge('synchro_queue_term', 'Synchro queue term', - info.synchro.queue.term) + info.synchro.queue.term, nil, nil, {default = true}) collectors_list.synchro_queue_len = utils.set_gauge('synchro_queue_len', 'Amount of transactions are collecting confirmations now', - info.synchro.queue.len) + info.synchro.queue.len, nil, nil, {default = true}) collectors_list.synchro_queue_busy = utils.set_gauge('synchro_queue_busy', 'Is synchro queue busy', - info.synchro.busy == true and 1 or 0) + info.synchro.busy == true and 1 or 0, nil, nil, {default = true}) end if info.election ~= nil then collectors_list.election_state = utils.set_gauge('election_state', 'Election state of the node', - election_states[info.election.state]) + election_states[info.election.state], nil, nil, {default = true}) collectors_list.election_vote = utils.set_gauge('election_vote', 'ID of a node the current node votes for', - info.election.vote) + info.election.vote, nil, nil, {default = true}) collectors_list.election_leader = utils.set_gauge('election_leader', 'Leader node ID in the current term', - info.election.leader) + info.election.leader, nil, nil, {default = true}) collectors_list.election_term = utils.set_gauge('election_term', 'Current election term', - info.election.term) + info.election.term, nil, nil, {default = true}) end end diff --git a/metrics/tarantool/luajit.lua b/metrics/tarantool/luajit.lua index ff607b04..8ecac11b 100644 --- a/metrics/tarantool/luajit.lua +++ b/metrics/tarantool/luajit.lua @@ -13,55 +13,62 @@ local function update() -- Details: https://github.com/tarantool/doc/issues/1597 local lj_metrics = misc.getmetrics() collectors_list.gc_freed_total = - utils.set_counter('gc_freed_total', 'Total amount of freed memory', lj_metrics.gc_freed, nil, LJ_PREFIX) + utils.set_counter('gc_freed_total', 'Total amount of freed memory', + lj_metrics.gc_freed, nil, LJ_PREFIX, {default = true}) collectors_list.strhash_hit_total = utils.set_counter('strhash_hit_total', 'Total number of strings being interned', - lj_metrics.strhash_hit, nil, LJ_PREFIX) + lj_metrics.strhash_hit, nil, LJ_PREFIX, {default = true}) collectors_list.gc_steps_atomic_total = utils.set_counter('gc_steps_atomic_total', 'Total count of incremental GC steps (atomic state)', - lj_metrics.gc_steps_atomic, nil, LJ_PREFIX) + lj_metrics.gc_steps_atomic, nil, LJ_PREFIX, {default = true}) collectors_list.strhash_miss_total = utils.set_counter('strhash_miss_total', 'Total number of strings allocations during the platform lifetime', - lj_metrics.strhash_miss, nil, LJ_PREFIX) + lj_metrics.strhash_miss, nil, LJ_PREFIX, {default = true}) collectors_list.gc_steps_sweepstring_total = utils.set_counter('gc_steps_sweepstring_total', 'Total count of incremental GC steps (sweepstring state)', - lj_metrics.gc_steps_sweepstring, nil, LJ_PREFIX) + lj_metrics.gc_steps_sweepstring, nil, LJ_PREFIX, {default = true}) collectors_list.gc_strnum = - utils.set_gauge('gc_strnum', 'Amount of allocated string objects', lj_metrics.gc_strnum, nil, LJ_PREFIX) + utils.set_gauge('gc_strnum', 'Amount of allocated string objects', + lj_metrics.gc_strnum, nil, LJ_PREFIX, {default = true}) collectors_list.gc_tabnum = - utils.set_gauge('gc_tabnum', 'Amount of allocated table objects', lj_metrics.gc_tabnum, nil, LJ_PREFIX) + utils.set_gauge('gc_tabnum', 'Amount of allocated table objects', + lj_metrics.gc_tabnum, nil, LJ_PREFIX, {default = true}) collectors_list.gc_cdatanum = - utils.set_gauge('gc_cdatanum', 'Amount of allocated cdata objects', lj_metrics.gc_cdatanum, nil, LJ_PREFIX) + utils.set_gauge('gc_cdatanum', 'Amount of allocated cdata objects', + lj_metrics.gc_cdatanum, nil, LJ_PREFIX, {default = true}) collectors_list.jit_snap_restore_total = utils.set_counter('jit_snap_restore_total', 'Overall number of snap restores', - lj_metrics.jit_snap_restore, nil, LJ_PREFIX) + lj_metrics.jit_snap_restore, nil, LJ_PREFIX, {default = true}) collectors_list.gc_memory = - utils.set_gauge('gc_memory', 'Memory currently allocated', lj_metrics.gc_total, nil, LJ_PREFIX) + utils.set_gauge('gc_memory', 'Memory currently allocated', + lj_metrics.gc_total, nil, LJ_PREFIX, {default = true}) collectors_list.gc_udatanum = - utils.set_gauge('gc_udatanum', 'Amount of allocated udata objects', lj_metrics.gc_udatanum, nil, LJ_PREFIX) + utils.set_gauge('gc_udatanum', 'Amount of allocated udata objects', + lj_metrics.gc_udatanum, nil, LJ_PREFIX, {default = true}) collectors_list.gc_steps_finalize_total = utils.set_counter('gc_steps_finalize_total', 'Total count of incremental GC steps (finalize state)', - lj_metrics.gc_steps_finalize, nil, LJ_PREFIX) + lj_metrics.gc_steps_finalize, nil, LJ_PREFIX, {default = true}) collectors_list.gc_allocated_total = utils.set_counter('gc_allocated_total', 'Total amount of allocated memory', - lj_metrics.gc_allocated, nil, LJ_PREFIX) + lj_metrics.gc_allocated, nil, LJ_PREFIX, {default = true}) collectors_list.jit_trace_num = - utils.set_gauge('jit_trace_num', 'Amount of JIT traces', lj_metrics.jit_trace_num, nil, LJ_PREFIX) + utils.set_gauge('jit_trace_num', 'Amount of JIT traces', + lj_metrics.jit_trace_num, nil, LJ_PREFIX, {default = true}) collectors_list.gc_steps_sweep_total = utils.set_counter('gc_steps_sweep_total', 'Total count of incremental GC steps (sweep state)', - lj_metrics.gc_steps_sweep, nil, LJ_PREFIX) + lj_metrics.gc_steps_sweep, nil, LJ_PREFIX, {default = true}) collectors_list.jit_trace_abort_total = utils.set_counter('jit_trace_abort_total', 'Overall number of abort traces', - lj_metrics.jit_trace_abort, nil, LJ_PREFIX) + lj_metrics.jit_trace_abort, nil, LJ_PREFIX, {default = true}) collectors_list.jit_mcode_size = utils.set_gauge('jit_mcode_size', 'Total size of all allocated machine code areas', - lj_metrics.jit_mcode_size, nil, LJ_PREFIX) + lj_metrics.jit_mcode_size, nil, LJ_PREFIX, {default = true}) collectors_list.gc_steps_propagate_total = utils.set_counter('gc_steps_propagate_total', 'Total count of incremental GC steps (propagate state)', - lj_metrics.gc_steps_propagate, nil, LJ_PREFIX) + lj_metrics.gc_steps_propagate, nil, LJ_PREFIX, {default = true}) collectors_list.gc_steps_pause_total = utils.set_counter('gc_steps_pause_total', 'Total count of incremental GC steps (pause state)', - lj_metrics.gc_steps_pause, nil, LJ_PREFIX) + lj_metrics.gc_steps_pause, nil, LJ_PREFIX, {default = true}) end return { diff --git a/metrics/tarantool/memory.lua b/metrics/tarantool/memory.lua index 2eade57a..766c162d 100644 --- a/metrics/tarantool/memory.lua +++ b/metrics/tarantool/memory.lua @@ -11,7 +11,8 @@ local function update_memory_metrics() local i = box.info.memory() for k, v in pairs(i) do local metric_name = 'info_memory_' .. k - collectors_list[metric_name] = utils.set_gauge(metric_name, 'Memory ' .. k, v) + collectors_list[metric_name] = utils.set_gauge(metric_name, 'Memory ' .. k, v, + nil, nil, {default = true}) end end end diff --git a/metrics/tarantool/memtx.lua b/metrics/tarantool/memtx.lua index 94eccd20..754b50c7 100644 --- a/metrics/tarantool/memtx.lua +++ b/metrics/tarantool/memtx.lua @@ -15,110 +15,110 @@ local function update() collectors_list.memtx_tnx_statements = utils.set_gauge('memtx_tnx_statements', 'Maximum number of bytes used by one transaction for statements', - memtx_stat.txn.statements.max, {kind = "max"}) + memtx_stat.txn.statements.max, {kind = "max"}, nil, {default = true}) collectors_list.memtx_tnx_statements = utils.set_gauge('memtx_tnx_statements', 'Average bytes used by transactions for statements', - memtx_stat.txn.statements.avg, {kind = "average"}) + memtx_stat.txn.statements.avg, {kind = "average"}, nil, {default = true}) collectors_list.memtx_tnx_statements = utils.set_gauge('memtx_tnx_statements', 'The number of bytes that are allocated for the statements of all current transactions', - memtx_stat.txn.statements.total, {kind = "total"}) + memtx_stat.txn.statements.total, {kind = "total"}, nil, {default = true}) collectors_list.memtx_tnx_user = utils.set_gauge('memtx_tnx_user', 'The maximum number of bytes allocated by `box_txn_alloc()` function per transaction', - memtx_stat.txn.user.max, {kind = "max"}) + memtx_stat.txn.user.max, {kind = "max"}, nil, {default = true}) collectors_list.memtx_tnx_user = utils.set_gauge('memtx_tnx_user', 'Transaction average (total memory / number of all current transactions)', - memtx_stat.txn.user.avg, {kind = "average"}) + memtx_stat.txn.user.avg, {kind = "average"}, nil, {default = true}) collectors_list.memtx_tnx_user = utils.set_gauge('memtx_tnx_user', 'Memory allocated by the `box_txn_alloc()` function on all current transactions', - memtx_stat.txn.user.total, {kind = "total"}) + memtx_stat.txn.user.total, {kind = "total"}, nil, {default = true}) collectors_list.memtx_tnx_system = utils.set_gauge('memtx_tnx_system', 'The maximum number of bytes allocated by internals per transaction', - memtx_stat.txn.system.max, {kind = "max"}) + memtx_stat.txn.system.max, {kind = "max"}, nil, {default = true}) collectors_list.memtx_tnx_system = utils.set_gauge('memtx_tnx_system', 'Average allocated memory by internals (total memory / number of all current transactions)', - memtx_stat.txn.system.avg, {kind = "average"}) + memtx_stat.txn.system.avg, {kind = "average"}, nil, {default = true}) collectors_list.memtx_tnx_system = utils.set_gauge('memtx_tnx_system', 'Memory allocated by internals on all transactions', - memtx_stat.txn.system.total, {kind = "total"}) + memtx_stat.txn.system.total, {kind = "total"}, nil, {default = true}) collectors_list.memtx_mvcc_trackers = utils.set_gauge('memtx_mvcc_trackers', 'Maximum trackers allocated per transaction', - memtx_stat.mvcc.trackers.max, {kind = "max"}) + memtx_stat.mvcc.trackers.max, {kind = "max"}, nil, {default = true}) collectors_list.memtx_mvcc_trackers = utils.set_gauge('memtx_mvcc_trackers', 'Average for all current transactions (total memory / number of transactions)', - memtx_stat.mvcc.trackers.avg, {kind = "average"}) + memtx_stat.mvcc.trackers.avg, {kind = "average"}, nil, {default = true}) collectors_list.memtx_mvcc_trackers = utils.set_gauge('memtx_mvcc_trackers', 'Trackers are allocated in total', - memtx_stat.mvcc.trackers.total, {kind = "total"}) + memtx_stat.mvcc.trackers.total, {kind = "total"}, nil, {default = true}) collectors_list.memtx_mvcc_conflicts = utils.set_gauge('memtx_mvcc_conflicts', 'Maximum bytes allocated for conflicts per transaction', - memtx_stat.mvcc.conflicts.max, {kind = "max"}) + memtx_stat.mvcc.conflicts.max, {kind = "max"}, nil, {default = true}) collectors_list.memtx_mvcc_conflicts = utils.set_gauge('memtx_mvcc_conflicts', 'Average for all current transactions (total memory / number of transactions)', - memtx_stat.mvcc.conflicts.avg, {kind = "average"}) + memtx_stat.mvcc.conflicts.avg, {kind = "average"}, nil, {default = true}) collectors_list.memtx_mvcc_conflicts = utils.set_gauge('memtx_mvcc_conflicts', 'Bytes allocated for conflicts in total', - memtx_stat.mvcc.conflicts.total, {kind = "total"}) + memtx_stat.mvcc.conflicts.total, {kind = "total"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_tracking_stories = utils.set_gauge('memtx_mvcc_tuples_tracking_stories', 'Number of `tracking` tuples / number of tracking stories.', - memtx_stat.mvcc.tuples.tracking.stories.count, {kind = "count"}) + memtx_stat.mvcc.tuples.tracking.stories.count, {kind = "count"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_tracking_stories = utils.set_gauge('memtx_mvcc_tuples_tracking_stories', 'Amount of bytes used by stories `tracking` tuples', - memtx_stat.mvcc.tuples.tracking.stories.total, {kind = "total"}) + memtx_stat.mvcc.tuples.tracking.stories.total, {kind = "total"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_tracking_retained = utils.set_gauge('memtx_mvcc_tuples_tracking_retained', 'Number of retained `tracking` tuples / number of stories', - memtx_stat.mvcc.tuples.tracking.retained.count, {kind = "count"}) + memtx_stat.mvcc.tuples.tracking.retained.count, {kind = "count"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_tracking_retained = utils.set_gauge('memtx_mvcc_tuples_tracking_retained', 'Amount of bytes used by retained `tracking` tuples', - memtx_stat.mvcc.tuples.tracking.retained.total, {kind = "total"}) + memtx_stat.mvcc.tuples.tracking.retained.total, {kind = "total"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_used_stories = utils.set_gauge('memtx_mvcc_tuples_used_stories', 'Number of `used` tuples / number of stories', - memtx_stat.mvcc.tuples.used.stories.count, {kind = "count"}) + memtx_stat.mvcc.tuples.used.stories.count, {kind = "count"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_used_stories = utils.set_gauge('memtx_mvcc_tuples_used_stories', 'Amount of bytes used by stories ``used`` tuples', - memtx_stat.mvcc.tuples.used.stories.total, {kind = "total"}) + memtx_stat.mvcc.tuples.used.stories.total, {kind = "total"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_used_retained = utils.set_gauge('memtx_mvcc_tuples_used_retained', 'Number of retained `used` tuples / number of stories', - memtx_stat.mvcc.tuples.used.retained.count, {kind = "count"}) + memtx_stat.mvcc.tuples.used.retained.count, {kind = "count"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_used_retained = utils.set_gauge('memtx_mvcc_tuples_used_retained', 'Amount of bytes used by retained `used` tuples', - memtx_stat.mvcc.tuples.used.retained.total, {kind = "total"}) + memtx_stat.mvcc.tuples.used.retained.total, {kind = "total"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_read_view_stories = utils.set_gauge('memtx_mvcc_tuples_read_view_stories', 'Number of `read_view` tuples / number of stories', - memtx_stat.mvcc.tuples.read_view.stories.count, {kind = "count"}) + memtx_stat.mvcc.tuples.read_view.stories.count, {kind = "count"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_read_view_stories = utils.set_gauge('memtx_mvcc_tuples_read_view_stories', 'Amount of bytes used by stories `read_view` tuples', - memtx_stat.mvcc.tuples.read_view.stories.total, {kind = "total"}) + memtx_stat.mvcc.tuples.read_view.stories.total, {kind = "total"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_read_view_retained = utils.set_gauge('memtx_mvcc_tuples_read_view_retained', 'Number of retained `read_view` tuples / number of stories', - memtx_stat.mvcc.tuples.read_view.retained.count, {kind = "count"}) + memtx_stat.mvcc.tuples.read_view.retained.count, {kind = "count"}, nil, {default = true}) collectors_list.memtx_mvcc_tuples_read_view_retained = utils.set_gauge('memtx_mvcc_tuples_read_view_retained', 'Amount of bytes used by retained `read_view` tuples', - memtx_stat.mvcc.tuples.read_view.retained.total, {kind = "total"}) + memtx_stat.mvcc.tuples.read_view.retained.total, {kind = "total"}, nil, {default = true}) end diff --git a/metrics/tarantool/network.lua b/metrics/tarantool/network.lua index 347a81e4..1f4dae5c 100644 --- a/metrics/tarantool/network.lua +++ b/metrics/tarantool/network.lua @@ -10,47 +10,56 @@ local function update_network_metrics() local box_stat_net = box.stat.net() collectors_list.net_sent_total = - utils.set_counter('net_sent_total', 'Totally sent in bytes', box_stat_net.SENT.total) + utils.set_counter('net_sent_total', 'Totally sent in bytes', + box_stat_net.SENT.total, nil, nil, {default = true}) collectors_list.net_received_total = - utils.set_counter('net_received_total', 'Totally received in bytes', box_stat_net.RECEIVED.total) + utils.set_counter('net_received_total', 'Totally received in bytes', + box_stat_net.RECEIVED.total, nil, nil, {default = true}) -- https://github.com/tarantool/doc/issues/760 -- before tnt version 2.2.0 if box_stat_net.CONNECTIONS ~= nil and type(box_stat_net.CONNECTIONS) ~= 'number' then collectors_list.net_connections_total = - utils.set_counter('net_connections_total', 'Connections total amount', box_stat_net.CONNECTIONS.total) + utils.set_counter('net_connections_total', 'Connections total amount', + box_stat_net.CONNECTIONS.total, nil, nil, {default = true}) collectors_list.net_connections_current = - utils.set_gauge('net_connections_current', 'Current connections amount', box_stat_net.CONNECTIONS.current) + utils.set_gauge('net_connections_current', 'Current connections amount', + box_stat_net.CONNECTIONS.current, nil, nil, {default = true}) elseif box_stat_net.CONNECTIONS ~= nil then collectors_list.net_connections_current = - utils.set_gauge('net_connections_current', 'Current connections amount', box_stat_net.CONNECTIONS) + utils.set_gauge('net_connections_current', 'Current connections amount', + box_stat_net.CONNECTIONS, nil, nil, {default = true}) end if box_stat_net.REQUESTS ~= nil then collectors_list.net_requests_total = - utils.set_counter('net_requests_total', 'Requests total amount', box_stat_net.REQUESTS.total) + utils.set_counter('net_requests_total', 'Requests total amount', + box_stat_net.REQUESTS.total, nil, nil, {default = true}) collectors_list.net_requests_current = - utils.set_gauge('net_requests_current', 'Pending requests', box_stat_net.REQUESTS.current) + utils.set_gauge('net_requests_current', 'Pending requests', + box_stat_net.REQUESTS.current, nil, nil, {default = true}) end if box_stat_net.REQUESTS_IN_PROGRESS ~= nil then collectors_list.net_requests_in_progress_total = utils.set_counter('net_requests_in_progress_total', 'Requests in progress total amount', - box_stat_net.REQUESTS_IN_PROGRESS.total) + box_stat_net.REQUESTS_IN_PROGRESS.total, nil, nil, {default = true}) collectors_list.net_requests_in_progress_current = utils.set_gauge('net_requests_in_progress_current', - 'Count of requests currently being processed in the tx thread', box_stat_net.REQUESTS_IN_PROGRESS.current) + 'Count of requests currently being processed in the tx thread', + box_stat_net.REQUESTS_IN_PROGRESS.current, nil, nil, {default = true}) end if box_stat_net.REQUESTS_IN_STREAM_QUEUE ~= nil then collectors_list.net_requests_in_stream_total = utils.set_counter('net_requests_in_stream_queue_total', 'Total count of requests, which was placed in queues of streams', - box_stat_net.REQUESTS_IN_STREAM_QUEUE.total) + box_stat_net.REQUESTS_IN_STREAM_QUEUE.total, nil, nil, {default = true}) collectors_list.net_requests_in_stream_current = utils.set_gauge('net_requests_in_stream_queue_current', - 'count of requests currently waiting in queues of streams', box_stat_net.REQUESTS_IN_STREAM_QUEUE.current) + 'count of requests currently waiting in queues of streams', + box_stat_net.REQUESTS_IN_STREAM_QUEUE.current, nil, nil, {default = true}) end if box.stat.net.thread ~= nil then @@ -61,58 +70,58 @@ local function update_network_metrics() collectors_list.net_per_thread_sent_total = utils.set_counter('net_per_thread_sent_total', 'Totally sent in bytes', - per_thread_mertics.SENT.total, {thread = index}) + per_thread_mertics.SENT.total, {thread = index}, nil, {default = true}) collectors_list.net_per_thread_received_total = utils.set_counter('net_per_thread_received_total', 'Totally received in bytes', - per_thread_mertics.RECEIVED.total, {thread = index}) + per_thread_mertics.RECEIVED.total, {thread = index}, nil, {default = true}) if per_thread_mertics.CONNECTIONS ~= nil and type(per_thread_mertics.CONNECTIONS) ~= 'number' then collectors_list.net_per_thread_connections_total = utils.set_counter('net_per_thread_connections_total', 'Connections total amount', - per_thread_mertics.CONNECTIONS.total, {thread = index}) + per_thread_mertics.CONNECTIONS.total, {thread = index}, nil, {default = true}) collectors_list.net_per_thread_connections_current = utils.set_gauge('net_per_thread_connections_current', 'Current connections amount', - per_thread_mertics.CONNECTIONS.current, {thread = index}) + per_thread_mertics.CONNECTIONS.current, {thread = index}, nil, {default = true}) elseif per_thread_mertics.CONNECTIONS ~= nil then collectors_list.net_per_thread_connections_current = utils.set_gauge('net_per_thread_connections_current', 'Current connections amount', - per_thread_mertics.CONNECTIONS, {thread = index}) + per_thread_mertics.CONNECTIONS, {thread = index}, nil, {default = true}) end if per_thread_mertics.REQUESTS ~= nil then collectors_list.net_per_thread_requests_total = utils.set_counter('net_per_thread_requests_total', 'Requests total amount', - per_thread_mertics.REQUESTS.total, {thread = index}) + per_thread_mertics.REQUESTS.total, {thread = index}, nil, {default = true}) collectors_list.net_per_thread_requests_current = utils.set_gauge('net_per_thread_requests_current', 'Pending requests', - per_thread_mertics.REQUESTS.current, {thread = index}) + per_thread_mertics.REQUESTS.current, {thread = index}, nil, {default = true}) end if per_thread_mertics.REQUESTS_IN_PROGRESS ~= nil then collectors_list.net_per_thread_requests_in_progress_total = utils.set_counter('net_per_thread_requests_in_progress_total', 'Requests in progress total amount', - per_thread_mertics.REQUESTS_IN_PROGRESS.total, {thread = index}) + per_thread_mertics.REQUESTS_IN_PROGRESS.total, {thread = index}, nil, {default = true}) collectors_list.net_per_thread_requests_in_progress_current = utils.set_gauge('net_per_thread_requests_in_progress_current', 'Count of requests currently being processed in the tx thread', - per_thread_mertics.REQUESTS_IN_PROGRESS.current, {thread = index}) + per_thread_mertics.REQUESTS_IN_PROGRESS.current, {thread = index}, nil, {default = true}) end if per_thread_mertics.REQUESTS_IN_STREAM_QUEUE ~= nil then collectors_list.net_per_thread_requests_in_stream_queue_total = utils.set_counter('net_per_thread_requests_in_stream_queue_total', 'Total count of requests, which was placed in queues of streams', - per_thread_mertics.REQUESTS_IN_STREAM_QUEUE.total, {thread = index}) + per_thread_mertics.REQUESTS_IN_STREAM_QUEUE.total, {thread = index}, nil, {default = true}) collectors_list.net_per_thread_requests_in_stream_queue_current = utils.set_gauge('net_per_thread_requests_in_stream_queue_current', 'Count of requests currently waiting in queues of streams', - per_thread_mertics.REQUESTS_IN_STREAM_QUEUE.current, {thread = index}) + per_thread_mertics.REQUESTS_IN_STREAM_QUEUE.current, {thread = index}, nil, {default = true}) end end end diff --git a/metrics/tarantool/operations.lua b/metrics/tarantool/operations.lua index 86831626..1368bfb7 100644 --- a/metrics/tarantool/operations.lua +++ b/metrics/tarantool/operations.lua @@ -11,7 +11,8 @@ local function update_operations_metrics() for k, v in pairs(current_stat) do collectors_list.stats_op_total = - utils.set_counter('stats_op_total', 'Total amount of operations', v.total, {operation = k:lower()}) + utils.set_counter('stats_op_total', 'Total amount of operations', + v.total, {operation = k:lower()}, nil, {default = true}) end end diff --git a/metrics/tarantool/replicas.lua b/metrics/tarantool/replicas.lua index a9942882..110501ba 100644 --- a/metrics/tarantool/replicas.lua +++ b/metrics/tarantool/replicas.lua @@ -15,7 +15,8 @@ local function update_replicas_metrics() if replication_info then local lsn = replication_info.lsn collectors_list.replication_lsn = - utils.set_gauge('replication_lsn', 'lsn for instance', lsn - v, {type = 'replica', id = k}) + utils.set_gauge('replication_lsn', 'lsn for instance', + lsn - v, {type = 'replica', id = k}, nil, {default = true}) end end else @@ -27,7 +28,9 @@ local function update_replicas_metrics() 'replication_lsn', 'lsn for instance', current_box_info.lsn - lsn, - {type = 'master', id = k} + {type = 'master', id = k}, + nil, + {default = true} ) end end diff --git a/metrics/tarantool/runtime.lua b/metrics/tarantool/runtime.lua index 00331b49..9763beed 100644 --- a/metrics/tarantool/runtime.lua +++ b/metrics/tarantool/runtime.lua @@ -8,7 +8,8 @@ local function update_runtime_metrics() for k, v in pairs(runtime_info) do if k ~= 'maxalloc' then local metric_name = 'runtime_' .. k - collectors_list[metric_name] = utils.set_gauge(metric_name, 'Runtime ' .. k, v) + collectors_list[metric_name] = utils.set_gauge(metric_name, 'Runtime ' .. k, v, + nil, nil, {default = true}) end end end diff --git a/metrics/tarantool/slab.lua b/metrics/tarantool/slab.lua index b1cd8f33..e802be32 100644 --- a/metrics/tarantool/slab.lua +++ b/metrics/tarantool/slab.lua @@ -12,10 +12,12 @@ local function update_slab_metrics() for k, v in pairs(slab_info) do local metric_name = 'slab_' .. k if not k:match('_ratio$') then - collectors_list[metric_name] = utils.set_gauge(metric_name, 'Slab ' .. k .. ' info', v) + collectors_list[metric_name] = utils.set_gauge(metric_name, 'Slab ' .. k .. ' info', v, + nil, nil, {default = true}) else collectors_list[metric_name] = - utils.set_gauge(metric_name, 'Slab ' .. k .. ' info', tonumber(v:match('^([0-9%.]+)%%?$'))) + utils.set_gauge(metric_name, 'Slab ' .. k .. ' info', tonumber(v:match('^([0-9%.]+)%%?$')), + nil, nil, {default = true}) end end end diff --git a/metrics/tarantool/spaces.lua b/metrics/tarantool/spaces.lua index fa0e1d0b..60da511c 100644 --- a/metrics/tarantool/spaces.lua +++ b/metrics/tarantool/spaces.lua @@ -34,7 +34,8 @@ local function update_spaces_metrics() local l = table.copy(labels) l.index_name = i.name collectors_list.space_index_bsize = - utils.set_gauge('space_index_bsize', 'Index bsize', i:bsize(), l) + utils.set_gauge('space_index_bsize', 'Index bsize', i:bsize(), l, + nil, {default = true}) total = total + i:bsize() if spaces[space_name] ~= nil then @@ -56,13 +57,16 @@ local function update_spaces_metrics() labels.engine = 'memtx' collectors_list.space_len = - utils.set_gauge('space_len' , 'Space length', sp:len(), labels) + utils.set_gauge('space_len' , 'Space length', sp:len(), labels, + nil, {default = true}) collectors_list.space_bsize = - utils.set_gauge('space_bsize', 'Space bsize', sp_bsize, labels) + utils.set_gauge('space_bsize', 'Space bsize', sp_bsize, labels, + nil, {default = true}) collectors_list.space_total_bsize = - utils.set_gauge('space_total_bsize', 'Space total bsize', sp_bsize + total, labels) + utils.set_gauge('space_total_bsize', 'Space total bsize', sp_bsize + total, labels, + nil, {default = true}) new_spaces[space_name].memtx_labels = labels spaces[space_name] = nil @@ -71,7 +75,8 @@ local function update_spaces_metrics() labels.engine = 'vinyl' local count = sp:count() collectors_list.vinyl_tuples = - utils.set_gauge('vinyl_tuples', 'Vinyl space tuples count', count, labels) + utils.set_gauge('vinyl_tuples', 'Vinyl space tuples count', count, labels, + nil, {default = true}) new_spaces[space_name].vinyl_labels = labels spaces[space_name] = nil diff --git a/metrics/tarantool/system.lua b/metrics/tarantool/system.lua index aef59b26..0b282fa4 100644 --- a/metrics/tarantool/system.lua +++ b/metrics/tarantool/system.lua @@ -8,7 +8,8 @@ local function update_system_metrics() return end - collectors_list.cfg_current_time = utils.set_gauge('cfg_current_time', 'Tarantool cfg time', clock.time() + 0ULL) + collectors_list.cfg_current_time = utils.set_gauge('cfg_current_time', 'Tarantool cfg time', clock.time() + 0ULL, + nil, nil, {default = true}) end return { diff --git a/metrics/tarantool/vinyl.lua b/metrics/tarantool/vinyl.lua index 07d97fe7..7a9ea34d 100644 --- a/metrics/tarantool/vinyl.lua +++ b/metrics/tarantool/vinyl.lua @@ -9,61 +9,73 @@ local function update() local vinyl_stat = box.stat.vinyl() collectors_list.vinyl_disk_data_size = - utils.set_gauge('vinyl_disk_data_size', 'Amount of data stored in files', vinyl_stat.disk.data) + utils.set_gauge('vinyl_disk_data_size', 'Amount of data stored in files', + vinyl_stat.disk.data, nil, nil, {default = true}) collectors_list.vinyl_disk_index_size = - utils.set_gauge('vinyl_disk_index_size', 'Amount of index stored in files', vinyl_stat.disk.index) + utils.set_gauge('vinyl_disk_index_size', 'Amount of index stored in files', + vinyl_stat.disk.index, nil, nil, {default = true}) collectors_list.vinyl_regulator_dump_bandwidth = utils.set_gauge('vinyl_regulator_dump_bandwidth', 'Estimated average rate at which dumps are done', - vinyl_stat.regulator.dump_bandwidth) + vinyl_stat.regulator.dump_bandwidth, nil, nil, {default = true}) collectors_list.vinyl_regulator_write_rate = utils.set_gauge('vinyl_regulator_write_rate', 'Average rate at which recent writes to disk are done', - vinyl_stat.regulator.write_rate) + vinyl_stat.regulator.write_rate, nil, nil, {default = true}) collectors_list.vinyl_regulator_rate_limit = - utils.set_gauge('vinyl_regulator_rate_limit', 'Write rate limit', vinyl_stat.regulator.rate_limit) + utils.set_gauge('vinyl_regulator_rate_limit', 'Write rate limit', + vinyl_stat.regulator.rate_limit, nil, nil, {default = true}) collectors_list.vinyl_regulator_dump_watermark = utils.set_gauge('vinyl_regulator_dump_watermark', 'Point when dumping must occur', - vinyl_stat.regulator.dump_watermark) + vinyl_stat.regulator.dump_watermark, nil, nil, {default = true}) if vinyl_stat.regulator.blocked_writers ~= nil then collectors_list.vinyl_regulator_blocked_writers = utils.set_gauge('vinyl_regulator_blocked_writers', 'The number of fibers that are blocked waiting ' .. - 'for Vinyl level0 memory quota', vinyl_stat.regulator.blocked_writers) + 'for Vinyl level0 memory quota', + vinyl_stat.regulator.blocked_writers, nil, nil, {default = true}) end collectors_list.vinyl_tx_conflict = - utils.set_gauge('vinyl_tx_conflict', 'Count of transaction conflicts', vinyl_stat.tx.conflict) + utils.set_gauge('vinyl_tx_conflict', 'Count of transaction conflicts', + vinyl_stat.tx.conflict, nil, nil, {default = true}) collectors_list.vinyl_tx_commit = - utils.set_gauge('vinyl_tx_commit', 'Count of commits', vinyl_stat.tx.commit) + utils.set_gauge('vinyl_tx_commit', 'Count of commits', + vinyl_stat.tx.commit, nil, nil, {default = true}) collectors_list.vinyl_tx_rollback = - utils.set_gauge('vinyl_tx_rollback', 'Count of rollbacks', vinyl_stat.tx.rollback) + utils.set_gauge('vinyl_tx_rollback', 'Count of rollbacks', + vinyl_stat.tx.rollback, nil, nil, {default = true}) collectors_list.vinyl_tx_read_views = - utils.set_gauge('vinyl_tx_read_views', 'Count of open read views', vinyl_stat.tx.read_views) + utils.set_gauge('vinyl_tx_read_views', 'Count of open read views', + vinyl_stat.tx.read_views, nil, nil, {default = true}) collectors_list.vinyl_memory_tuple_cache = utils.set_gauge('vinyl_memory_tuple_cache', 'Number of bytes that are being used for tuple', - vinyl_stat.memory.tuple_cache) + vinyl_stat.memory.tuple_cache, nil, nil, {default = true}) collectors_list.vinyl_memory_level0 = - utils.set_gauge('vinyl_memory_level0', 'Size of in-memory storage of an LSM tree', vinyl_stat.memory.level0) + utils.set_gauge('vinyl_memory_level0', 'Size of in-memory storage of an LSM tree', + vinyl_stat.memory.level0, nil, nil, {default = true}) collectors_list.vinyl_memory_page_index = - utils.set_gauge('vinyl_memory_page_index', 'Size of page indexes', vinyl_stat.memory.page_index) + utils.set_gauge('vinyl_memory_page_index', 'Size of page indexes', + vinyl_stat.memory.page_index, nil, nil, {default = true}) collectors_list.vinyl_memory_bloom_filter = - utils.set_gauge('vinyl_memory_bloom_filter', 'Size of bloom filter', vinyl_stat.memory.bloom_filter) + utils.set_gauge('vinyl_memory_bloom_filter', 'Size of bloom filter', + vinyl_stat.memory.bloom_filter, nil, nil, {default = true}) collectors_list.vinyl_scheduler_tasks = - utils.set_gauge('vinyl_scheduler_tasks', 'Vinyl tasks count', vinyl_stat.scheduler.tasks_inprogress, - {status = 'inprogress'}) + utils.set_gauge('vinyl_scheduler_tasks', 'Vinyl tasks count', + vinyl_stat.scheduler.tasks_inprogress, {status = 'inprogress'}, nil, {default = true}) collectors_list.vinyl_scheduler_tasks = - utils.set_gauge('vinyl_scheduler_tasks', 'Vinyl tasks count', vinyl_stat.scheduler.tasks_completed, - {status = 'completed'}) + utils.set_gauge('vinyl_scheduler_tasks', 'Vinyl tasks count', + vinyl_stat.scheduler.tasks_completed, {status = 'completed'}, nil, {default = true}) collectors_list.vinyl_scheduler_tasks = - utils.set_gauge('vinyl_scheduler_tasks', 'Vinyl tasks count', vinyl_stat.scheduler.tasks_failed, - {status = 'failed'}) + utils.set_gauge('vinyl_scheduler_tasks', 'Vinyl tasks count', + vinyl_stat.scheduler.tasks_failed, {status = 'failed'}, nil, {default = true}) collectors_list.vinyl_scheduler_dump_time = utils.set_gauge('vinyl_scheduler_dump_time', 'Total time spent by all worker threads performing dump', - vinyl_stat.scheduler.dump_time) + vinyl_stat.scheduler.dump_time, nil, nil, {default = true}) collectors_list.vinyl_scheduler_dump_total = - utils.set_counter('vinyl_scheduler_dump_total', 'The count of completed dumps', vinyl_stat.scheduler.dump_count) + utils.set_counter('vinyl_scheduler_dump_total', 'The count of completed dumps', + vinyl_stat.scheduler.dump_count, nil, nil, {default = true}) end return { diff --git a/test/metrics_test.lua b/test/metrics_test.lua index 1c7ca5f1..91538902 100755 --- a/test/metrics_test.lua +++ b/test/metrics_test.lua @@ -189,3 +189,13 @@ for name, case in pairs(collect_invoke_callbacks_cases) do t.assert_equals(obs.value, case.value) end end + +g.test_default_metrics_metainfo = function() + metrics.enable_default_metrics() + metrics.invoke_callbacks() + + for k, c in pairs(metrics.collectors()) do + t.assert_equals(c.metainfo.default, true, + ('default collector %s has metainfo label "default"'):format(k)) + end +end diff --git a/test/psutils_linux_thread_clean_test.lua b/test/psutils_linux_thread_clean_test.lua index 223da520..a5310444 100644 --- a/test/psutils_linux_thread_clean_test.lua +++ b/test/psutils_linux_thread_clean_test.lua @@ -94,3 +94,12 @@ g.test_clear = function() cpu.update() check_cpu_metrics(true) end + +g.test_default_metrics_metainfo = function() + cpu.update() + + for k, c in pairs(metrics.collectors()) do + t.assert_equals(c.metainfo.default, true, + ('psutils collector %s has metainfo label "default"'):format(k)) + end +end From 7c87de12f3dd45c019a1e60209999f5c66160436 Mon Sep 17 00:00:00 2001 From: Georgy Moiseev Date: Thu, 26 Jan 2023 11:23:36 +0300 Subject: [PATCH 4/5] api: allow to collect only default metrics After this patch, it is possible to collect only default metrics in Lua. Collector metainfo is used to decide which metric is default and which is not. Beware that collect does not control the list of enabled metrics -- if some (or all) default metrics were disabled or weren't enabled, they won't be appear in observation. The motivation is a requirement from Tarantool Feedback Daemon [1] to collect default metrics, but not the user ones. 1. https://github.com/tarantool/tarantool/issues/8192 Part of tarantool/tarantool#8192, part of tarantool/tarantool#7725 --- CHANGELOG.md | 1 + doc/monitoring/api_reference.rst | 1 + metrics/init.lua | 21 +++++++++++++++++-- test/metrics_test.lua | 35 ++++++++++++++++++++++++++++++++ 4 files changed, 56 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 0b98e9d0..1755dc1d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Ability to set metainfo for collectors - Set `metainfo.default` to `true` for all collectors from `enable_default_metrics()` and psutils collectors +- `default_only` option for `metrics.collect()` ### Fixed diff --git a/doc/monitoring/api_reference.rst b/doc/monitoring/api_reference.rst index 9bdceb54..128ca3fb 100644 --- a/doc/monitoring/api_reference.rst +++ b/doc/monitoring/api_reference.rst @@ -360,6 +360,7 @@ Metrics functions :param table opts: table of collect options: * ``invoke_callbacks`` -- if ``true``, ``invoke_callbacks()`` is triggerred before actual collect. + * ``default_only`` -- if ``true``, observations contain only default metrics (``metainfo.default = true``). .. class:: registry diff --git a/metrics/init.lua b/metrics/init.lua index e44f1877..56eae4ec 100644 --- a/metrics/init.lua +++ b/metrics/init.lua @@ -41,15 +41,32 @@ local function invoke_callbacks() return registry:invoke_callbacks() end +local function get_collector_values(collector, result) + for _, obs in ipairs(collector:collect()) do + table.insert(result, obs) + end +end + local function collect(opts) - checks({invoke_callbacks = '?boolean'}) + checks({invoke_callbacks = '?boolean', default_only = '?boolean'}) opts = opts or {} if opts.invoke_callbacks then registry:invoke_callbacks() end - return registry:collect() + local result = {} + for _, collector in pairs(registry.collectors) do + if opts.default_only then + if collector.metainfo.default then + get_collector_values(collector, result) + end + else + get_collector_values(collector, result) + end + end + + return result end local function clear() diff --git a/test/metrics_test.lua b/test/metrics_test.lua index 91538902..1a58cb9e 100755 --- a/test/metrics_test.lua +++ b/test/metrics_test.lua @@ -199,3 +199,38 @@ g.test_default_metrics_metainfo = function() ('default collector %s has metainfo label "default"'):format(k)) end end + +local collect_default_only_cases = { + default = { + args = {invoke_callbacks = true}, + custom_expected = true, + }, + ['true'] = { + args = {invoke_callbacks = true, default_only = true}, + custom_expected = false, + }, + ['false'] = { + args = {invoke_callbacks = true, default_only = false}, + custom_expected = true, + }, +} + +for name, case in pairs(collect_default_only_cases) do + g['test_collect_default_only_' .. name] = function() + metrics.enable_default_metrics() + local c = metrics.gauge('custom_metric') + c:set(42) + + local observations = metrics.collect(case.args) + + local default_obs = utils.find_metric('tnt_info_memory_lua', observations) + t.assert_not_equals(default_obs, nil) + + local custom_obs = utils.find_metric('custom_metric', observations) + if case.custom_expected then + t.assert_not_equals(custom_obs, nil) + else + t.assert_equals(custom_obs, nil) + end + end +end From dceb3d32fb19dfd52433309ffc1b17195f07308a Mon Sep 17 00:00:00 2001 From: Georgy Moiseev Date: Thu, 26 Jan 2023 14:24:22 +0300 Subject: [PATCH 5/5] ci: run on pull requests with slash in name If branch name has slash in name, it didn't passes the `'*'` Github Actions regexp. --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index f8917c72..d6df0fe6 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -2,7 +2,7 @@ name: Tests on: push: branches: - - '*' + - '**' paths-ignore: - 'doc/**' jobs: