move to the separate module, rename metamethod

metrics/api.lua

@@ -9,6 +9,8 @@ local Gauge = require('metrics.collectors.gauge')
 local Histogram = require('metrics.collectors.histogram')
 local Summary = require('metrics.collectors.summary')
 
+local serializers = require("metrics.serializers")
+
 local registry = rawget(_G, '__metrics_registry')
 if not registry then
     registry = Registry.new()
@@ -125,76 +127,6 @@ local function set_global_labels(label_pairs)
     registry:set_labels(label_pairs)
 end
 
---- Prepares a serializer for label pairs with given keys.
----
---- `make_key`, which is used during every metric-related operation, is not very efficient itself.
---- To mitigate it, one could add his own serialization implementation.
---- It is done via passing `__metrics_make_key` callback to the label pairs table.
----
---- This function gives you ready-to-use serializer, so you don't have to create one yourself.
----
---- BEWARE! If keys of the `label_pairs` somehow change between serialization turns, it would raise error mostlikely.
---- We cover internal cases already, for example, "le" key is always added for the histograms.
----
---- @class LabelsSerializer
---- @field wrap function(label_pairs: table): table Wraps given `label_pairs` with an efficient serialization.
---- @field serialize function(label_pairs: table): string Serialize given `label_pairs` into the key.
---- Exposed so you can write your own serializers on top of it.
----
---- @param labels_keys string[] Label keys for the further use.
---- @return LabelsSerializer
-local function labels_serializer(labels_keys)
-    -- we always add keys that are needed for metrics' internals.
-    local __labels_keys = { "le" }
-    -- used to protect label_pairs from altering with unexpected keys.
-    local keys_index = { le = true }
-
-    -- keep only unique labels
-    for _, key in ipairs(labels_keys) do
-        if not keys_index[key] then
-            table.insert(__labels_keys, key)
-            keys_index[key] = true
-        end
-    end
-    table.sort(__labels_keys)
-
-    local function serialize(label_pairs)
-        local result = ""
-        for _, label in ipairs(__labels_keys) do
-            local value = label_pairs[label]
-            if value ~= nil then
-                if result ~= "" then
-                    result = result .. '\t'
-                end
-                result = result .. label .. '\t' .. value
-            end
-        end
-        return result
-    end
-
-    local pairs_metatable = {
-        __index = {
-            __metrics_make_key = function(self)
-                return serialize(self)
-            end
-        },
-        -- It protects pairs from being altered with unexpected labels.
-        __newindex = function(table, key, value)
-            if not keys_index[key] then
-                error(('Label "%s" is unexpected'):format(key), 2)
-            end
-            rawset(table, key, value)
-        end
-    }
-
-    return {
-        wrap = function(label_pairs)
-            return setmetatable(label_pairs, pairs_metatable)
-        end,
-        serialize = serialize
-    }
-end
-
 return {
     registry = registry,
     collectors = collectors,
@@ -210,5 +142,5 @@ return {
     unregister_callback = unregister_callback,
     invoke_callbacks = invoke_callbacks,
     set_global_labels = set_global_labels,
-    labels_serializer = labels_serializer
+    labels_serializer = serializers.basic_labels_serializer
 }

metrics/collectors/shared.lua

@@ -1,6 +1,7 @@
 local clock = require('clock')
 local fiber = require('fiber')
 local log = require('log')
+local serializers = require("metrics.serializers")
 
 local Shared = {}
 
@@ -48,15 +49,10 @@ function Shared.make_key(label_pairs)
         return ""
     end
     -- `label_pairs` provides its own serialization scheme, it must be used instead of default one.
-    if label_pairs.__metrics_make_key then
-        return label_pairs:__metrics_make_key()
+    if label_pairs.__metrics_serialize then
+        return label_pairs:__metrics_serialize()
     end
-    local parts = {}
-    for k, v in pairs(label_pairs) do
-        table.insert(parts, k .. '\t' .. v)
-    end
-    table.sort(parts)
-    return table.concat(parts, '\t')
+    return serializers.default_labels_serializer(label_pairs)
 end
 
 function Shared:remove(label_pairs)

metrics/serializers.lua

@@ -0,0 +1,86 @@
+--- Default slow algorithm, polluted with sorting.
+--- It is used when nothing is known about `label_pairs`.
+local function default_labels_serializer(label_pairs)
+    local parts = {}
+    for k, v in pairs(label_pairs) do
+        table.insert(parts, k .. '\t' .. v)
+    end
+    table.sort(parts)
+    return table.concat(parts, '\t')
+end
+
+
+--- Prepares a serializer for label pairs with given keys.
+---
+--- `make_key`, which is used during every metric-related operation, is not very efficient itself.
+--- To mitigate it, one could add his own serialization implementation.
+--- It is done via passing `__metrics_serialize` callback to the label pairs table.
+---
+--- This function gives you ready-to-use serializer, so you don't have to create one yourself.
+---
+--- BEWARE! If keys of the `label_pairs` somehow change between serialization turns, it would raise error mostlikely.
+--- We cover internal cases already, for example, "le" key is always added for the histograms.
+---
+--- @class LabelsSerializer
+--- @field wrap function(label_pairs: table): table Wraps given `label_pairs` with an efficient serialization.
+--- @field serialize function(label_pairs: table): string Serialize given `label_pairs` into the key.
+--- Exposed so you can write your own serializers on top of it.
+---
+--- @param labels_keys string[] Label keys for the further use.
+--- @return LabelsSerializer
+local function basic_labels_serializer(labels_keys)
+    -- we always add keys that are needed for metrics' internals.
+    local __labels_keys = { "le" }
+    -- used to protect label_pairs from altering with unexpected keys.
+    local keys_index = { le = true }
+
+    -- keep only unique labels
+    for _, key in ipairs(labels_keys) do
+        if not keys_index[key] then
+            table.insert(__labels_keys, key)
+            keys_index[key] = true
+        end
+    end
+    table.sort(__labels_keys)
+
+    local function serialize(label_pairs)
+        local result = ""
+        for _, label in ipairs(__labels_keys) do
+            local value = label_pairs[label]
+            if value ~= nil then
+                if result ~= "" then
+                    result = result .. '\t'
+                end
+                result = result .. label .. '\t' .. value
+            end
+        end
+        return result
+    end
+
+    local pairs_metatable = {
+        __index = {
+            __metrics_serialize = function(self)
+                return serialize(self)
+            end
+        },
+        -- It protects pairs from being altered with unexpected labels.
+        __newindex = function(table, key, value)
+            if not keys_index[key] then
+                error(('Label "%s" is unexpected'):format(key), 2)
+            end
+            rawset(table, key, value)
+        end
+    }
+
+    return {
+        wrap = function(label_pairs)
+            return setmetatable(label_pairs, pairs_metatable)
+        end,
+        serialize = serialize
+    }
+end
+
+return {
+    default_labels_serializer = default_labels_serializer,
+    basic_labels_serializer = basic_labels_serializer
+}

test/metrics_test.lua

@@ -291,7 +291,7 @@ g.test_labels_serializer_consistent = function()
 
     t.assert_equals(actual, shared.make_key(label_pairs))
     t.assert_equals(actual, shared.make_key(wrapped))
-    t.assert_not_equals(wrapped.__metrics_make_key, nil)
+    t.assert_not_equals(wrapped.__metrics_serialize, nil)
 
     -- trying to set unexpected label.
     t.assert_error_msg_contains('Label "new_label" is unexpected', function() wrapped.new_label = "123456" end)