Optimize text format scrape hot path (#202)

* Pre-compute metric name and help as binaries at declaration time

During every scrape, metric name and help were converted from
atom/list to binary via ensure_binary_or_string/1 in create_mf.
With many metric families this repeated work adds up, especially
the atom_to_binary calls that show up in profiling.

Now, extract_common_params/1 returns pre-computed NameBin and
HelpBin, stored in ETS as a 3-tuple {Labels, HelpBin, NameBin}
alongside label definitions. All six built-in metric collectors
(boolean, counter, gauge, histogram, quantile_summary, summary)
pass these binaries directly into create_mf, avoiding per-scrape
conversion entirely.

A normalize_mf_row/1 function in prometheus_metric handles backward
compatibility: old ETS entries with the 2-tuple {Labels, Help}
format are normalized on read, so hot upgrades don't crash.

* prometheus_model_helpers: Optimize hot path for metric record creation

Profiling (tprof) of a RabbitMQ workload shows gauge_metric/2 at
16.32% and counter_metric/2 at 2.45% of total process time, with
~2M calls each allocating 12 words of intermediate records that the
text format immediately destructures and discards.

This commit applies several targeted optimizations:

- Inline gauge_metric/2, counter_metric/2, and label_pair/1 to
  eliminate function call overhead on these ~2M-call-per-scrape
  functions.

- Add a fast path in create_mf/4 that detects when the input list
  already contains #'Metric'{} records (as all built-in collectors
  produce), skipping the metrics_from_tuples/2 dispatch entirely.
  This avoids the per-element is_record check and type-based
  dispatch for every metric.

- Replace lists:map(fun label_pair/1, Labels) with a list
  comprehension, which the compiler can optimize better when
  combined with the inline directive.

- Add integer and float clauses to ensure_binary_or_string/1,
  avoiding the expensive io_lib:format("~p", [Val]) fallback for
  numeric label values.

* prometheus_model_helpers: Merge filter and map into single pass

metrics_from_tuples/2 previously traversed the list twice: once
via filter_undefined_metrics (lists:filter) to remove undefined
entries, then a list comprehension to convert tuples to records.
Profiling shows lists:filter alone at 3.26% of scrape time with
~2.4M elements.

Fold both operations into a single list comprehension with a
guard filter. Apply the same pattern to the create_mf/4 fast path
for pre-built #'Metric'{} records.

* prometheus_text_format: Inline render_series/4 and render_value/2

These two functions are called once per metric series during every
scrape (~2.3M calls each in profiled RabbitMQ workloads), together
accounting for ~15.6% of scrape time. Inlining eliminates the
function call overhead and allows the compiler to optimize the
binary append operations across call boundaries.

* Apply review comments

Author: NelsonVides

src/formats/prometheus_text_format.erl

@@ -35,7 +35,7 @@ http_request_duration_milliseconds_sum{method=\"post\"} 4350
 -include("prometheus_model.hrl").
 
 -behaviour(prometheus_format).
--compile({inline, [render_label_pair/1]}).
+-compile({inline, [render_label_pair/1, render_series/4, render_value/2]}).
 
 ?DOC("""
 Returns content type of the latest \[text format](https://bit.ly/2cxSuJP).

src/metrics/prometheus_boolean.erl

@@ -326,14 +326,16 @@ deregister_cleanup(Registry) ->
 -spec collect_mf(prometheus_registry:registry(), prometheus_collector:collect_mf_callback()) -> ok.
 collect_mf(Registry, Callback) ->
     [
-        Callback(create_boolean(Name, Help, {CLabels, Labels, Registry}))
-     || [Name, {Labels, Help}, CLabels, _, _] <- prometheus_metric:metrics(?TABLE, Registry)
+        Callback(create_boolean(NameBin, HelpBin, {CLabels, Labels, Registry, Name}))
+     || [Name, {Labels, HelpBin, NameBin}, CLabels, _, _] <- prometheus_metric:metrics(
+            ?TABLE, Registry
+        )
     ],
     ok.
 
 ?DOC(false).
 -spec collect_metrics(prometheus_metric:name(), tuple()) -> [prometheus_model:'Metric'()].
-collect_metrics(Name, {CLabels, Labels, Registry}) ->
+collect_metrics(_NameBin, {CLabels, Labels, Registry, Name}) ->
     [
         prometheus_model_helpers:boolean_metric(
             CLabels ++ lists:zip(Labels, LabelValues), Value

src/metrics/prometheus_counter.erl

@@ -336,15 +336,17 @@ deregister_cleanup(Registry) ->
 -spec collect_mf(prometheus_registry:registry(), prometheus_collector:collect_mf_callback()) -> ok.
 collect_mf(Registry, Callback) ->
     [
-        Callback(create_counter(Name, Help, {CLabels, Labels, Registry}))
-     || [Name, {Labels, Help}, CLabels, _, _] <- prometheus_metric:metrics(?TABLE, Registry)
+        Callback(create_counter(NameBin, HelpBin, {CLabels, Labels, Registry, Name}))
+     || [Name, {Labels, HelpBin, NameBin}, CLabels, _, _] <- prometheus_metric:metrics(
+            ?TABLE, Registry
+        )
     ],
     ok.
 
 ?DOC(false).
 -spec collect_metrics(prometheus_metric:name(), tuple()) ->
     [prometheus_model:'Metric'()].
-collect_metrics(Name, {CLabels, Labels, Registry}) ->
+collect_metrics(_NameBin, {CLabels, Labels, Registry, Name}) ->
     MFValues = load_all_values(Registry, Name),
     LabelValues = reduce_label_values(MFValues),
     Fun = fun(VLabels, Value) ->

src/metrics/prometheus_gauge.erl

@@ -529,15 +529,17 @@ deregister_cleanup(Registry) ->
 -spec collect_mf(prometheus_registry:registry(), prometheus_collector:collect_mf_callback()) -> ok.
 collect_mf(Registry, Callback) ->
     [
-        Callback(create_gauge(Name, Help, {CLabels, Labels, Registry, DU}))
-     || [Name, {Labels, Help}, CLabels, DU, _] <- prometheus_metric:metrics(?TABLE, Registry)
+        Callback(create_gauge(NameBin, HelpBin, {CLabels, Labels, Registry, DU, Name}))
+     || [Name, {Labels, HelpBin, NameBin}, CLabels, DU, _] <- prometheus_metric:metrics(
+            ?TABLE, Registry
+        )
     ],
     ok.
 
 ?DOC(false).
 -spec collect_metrics(prometheus_metric:name(), tuple()) ->
     [prometheus_model:'Metric'()].
-collect_metrics(Name, {CLabels, Labels, Registry, DU}) ->
+collect_metrics(_NameBin, {CLabels, Labels, Registry, DU, Name}) ->
     [
         prometheus_model_helpers:gauge_metric(
             CLabels ++ lists:zip(Labels, LabelValues),

src/metrics/prometheus_histogram.erl

@@ -495,15 +495,17 @@ deregister_cleanup(Registry) ->
 -spec collect_mf(prometheus_registry:registry(), prometheus_collector:collect_mf_callback()) -> ok.
 collect_mf(Registry, Callback) ->
     [
-        Callback(create_histogram(Name, Help, {CLabels, Labels, Registry, DU, Buckets}))
-     || [Name, {Labels, Help}, CLabels, DU, Buckets] <- prometheus_metric:metrics(?TABLE, Registry)
+        Callback(create_histogram(NameBin, HelpBin, {CLabels, Labels, Registry, DU, Buckets, Name}))
+     || [Name, {Labels, HelpBin, NameBin}, CLabels, DU, Buckets] <- prometheus_metric:metrics(
+            ?TABLE, Registry
+        )
     ],
     ok.
 
 ?DOC(false).
 -spec collect_metrics(prometheus_metric:name(), tuple()) ->
     [prometheus_model:'Metric'()].
-collect_metrics(Name, {CLabels, Labels, Registry, DU, Bounds}) ->
+collect_metrics(_NameBin, {CLabels, Labels, Registry, DU, Bounds, Name}) ->
     MFValues = load_all_values(Registry, Name, Bounds),
     LabelValuesMap = reduce_label_values(MFValues),
     Fun = fun(LabelValues, Stat, L) ->

src/metrics/prometheus_quantile_summary.erl

@@ -381,15 +381,15 @@ deregister_cleanup(Registry) ->
 collect_mf(Registry, Callback) ->
     Metrics = prometheus_metric:metrics(?TABLE, Registry),
     [
-        Callback(create_summary(Name, Help, {CLabels, Labels, Registry, DU, Data}))
-     || [Name, {Labels, Help}, CLabels, DU, Data] <- Metrics
+        Callback(create_summary(NameBin, HelpBin, {CLabels, Labels, Registry, DU, Data, Name}))
+     || [Name, {Labels, HelpBin, NameBin}, CLabels, DU, Data] <- Metrics
     ],
     ok.
 
 ?DOC(false).
 -spec collect_metrics(prometheus_metric:name(), tuple()) ->
     [prometheus_model:'Metric'()].
-collect_metrics(Name, {CLabels, Labels, Registry, _DU, _Configuration}) ->
+collect_metrics(_NameBin, {CLabels, Labels, Registry, _DU, _Configuration, Name}) ->
     Fun = fun model_summary_metric/6,
     loop_through_keys(Name, Fun, CLabels, Labels, Registry).
 

src/metrics/prometheus_summary.erl

@@ -376,15 +376,17 @@ deregister_cleanup(Registry) ->
 -spec collect_mf(prometheus_registry:registry(), prometheus_collector:collect_mf_callback()) -> ok.
 collect_mf(Registry, Callback) ->
     [
-        Callback(create_summary(Name, Help, {CLabels, Labels, Registry, DU}))
-     || [Name, {Labels, Help}, CLabels, DU, _] <- prometheus_metric:metrics(?TABLE, Registry)
+        Callback(create_summary(NameBin, HelpBin, {CLabels, Labels, Registry, DU, Name}))
+     || [Name, {Labels, HelpBin, NameBin}, CLabels, DU, _] <- prometheus_metric:metrics(
+            ?TABLE, Registry
+        )
     ],
     ok.
 
 ?DOC(false).
 -spec collect_metrics(prometheus_metric:name(), tuple()) ->
     [prometheus_model:'Metric'()].
-collect_metrics(Name, {CLabels, Labels, Registry, DU}) ->
+collect_metrics(_NameBin, {CLabels, Labels, Registry, DU, Name}) ->
     MFValues = load_all_values(Registry, Name),
     ReducedMap = lists:foldl(
         fun([L, C, IS, FS], ResAcc) ->

src/model/prometheus_model_helpers.erl

@@ -45,14 +45,15 @@ Probably will be used with `m:prometheus_collector`.
 
 -ifdef(TEST).
 -export([
-    filter_undefined_metrics/1,
     ensure_mf_type/1,
     ensure_binary_or_string/1
 ]).
 -endif.
 
 -include("prometheus_model.hrl").
 
+-compile({inline, [label_pair/1, label_pair/2, gauge_metric/2, counter_metric/2]}).
+
 %%%===================================================================
 %%% Public API
 %%%===================================================================
@@ -100,6 +101,16 @@ Create Metric Family of `Type`, `Name` and `Help`.
     MetricFamily :: prometheus_model:'MetricFamily'().
 create_mf(Name, Help, Type, Metrics) when is_map(Metrics) ->
     create_mf(Name, Help, Type, maps:to_list(Metrics));
+create_mf(Name, Help, Type, [First | _] = Metrics0) when
+    is_list(Metrics0), is_record(First, 'Metric')
+->
+    %% Fast path: metrics are already #'Metric'() records, skip metrics_from_tuples
+    #'MetricFamily'{
+        name = ensure_binary_or_string(Name),
+        help = ensure_binary_or_string(Help),
+        type = ensure_mf_type(Type),
+        metric = [M || M <- Metrics0, M =/= undefined]
+    };
 create_mf(Name, Help, Type, Metrics0) ->
     Metrics = metrics_from_tuples(Type, Metrics0),
     #'MetricFamily'{
@@ -340,15 +351,18 @@ fail with an error.
 label_pairs(B) when is_binary(B) ->
     B;
 label_pairs(Labels) when is_list(Labels) ->
-    lists:map(fun label_pair/1, Labels);
+    [label_pair(L) || L <- Labels];
 label_pairs(Labels) when is_map(Labels) ->
-    lists:map(fun label_pair/1, maps:to_list(Labels)).
+    [label_pair(Name, Value) || Name := Value <- Labels].
 
 ?DOC("""
 Creates `prometheus_model:`LabelPair'()' from \{Name, Value\} tuple.
 """).
 -spec label_pair(prometheus:label()) -> prometheus_model:'LabelPair'().
 label_pair({Name, Value}) ->
+    label_pair(Name, Value).
+
+label_pair(Name, Value) ->
     #'LabelPair'{
         name = ensure_binary_or_string(Name),
         value = ensure_binary_or_string(Value)
@@ -373,10 +387,7 @@ histogram_bucket({Bound, Count}) ->
     }.
 
 metrics_from_tuples(Type, Metrics) ->
-    [
-        metric_from_tuple(Type, Metric)
-     || Metric <- filter_undefined_metrics(ensure_list(Metrics))
-    ].
+    [metric_from_tuple(Type, M) || M <- ensure_list(Metrics), M =/= undefined].
 
 metric_from_tuple(_, Metric) when is_record(Metric, 'Metric') ->
     Metric;
@@ -397,20 +408,14 @@ metric_from_tuple(untyped, Metric) ->
 ensure_list(Val) when is_list(Val) -> Val;
 ensure_list(Val) -> [Val].
 
-?DOC(false).
--spec filter_undefined_metrics([undefined | T]) -> [T].
-filter_undefined_metrics(Metrics) ->
-    lists:filter(fun not_undefined/1, Metrics).
-
-not_undefined(undefined) -> false;
-not_undefined(_) -> true.
-
 ?DOC(false).
 -spec ensure_binary_or_string(Val :: term()) -> binary() | string().
 ensure_binary_or_string(Val) when is_atom(Val) -> atom_to_binary(Val, utf8);
 %% FIXME: validate utf8
 ensure_binary_or_string(Val) when is_list(Val) -> Val;
 ensure_binary_or_string(Val) when is_binary(Val) -> Val;
+ensure_binary_or_string(Val) when is_integer(Val) -> integer_to_binary(Val);
+ensure_binary_or_string(Val) when is_float(Val) -> float_to_binary(Val, [short]);
 ensure_binary_or_string(Val) -> io_lib:format("~p", [Val]).
 
 ?DOC(false).

src/prometheus_collector.erl

@@ -43,7 +43,7 @@ collect_mf(_Registry, Callback) ->
                           Memory)),
     ok.
 
-collect_metrics(erlang_vm_bytes_total, Memory) ->
+collect_metrics(_Name, Memory) ->
     prometheus_model_helpers:gauge_metrics(
       [
         {[{kind, system}], proplists:get_value(system,  Memory)},

src/prometheus_metric.erl

@@ -147,10 +147,10 @@ insert_new_mf(Table, Module, Spec) ->
     Module :: atom(),
     Spec :: spec().
 insert_mf(Table, Module, Spec) ->
-    {Registry, Name, Labels, Help, CLabels, DurationUnit, Data} =
+    {Registry, Name, Labels, _Help, CLabels, DurationUnit, Data, NameBin, HelpBin} =
         prometheus_metric_spec:extract_common_params(Spec),
     prometheus_registry:register_collector(Registry, Module),
-    Tuple = {{Registry, mf, Name}, {Labels, Help}, CLabels, DurationUnit, Data},
+    Tuple = {{Registry, mf, Name}, {Labels, HelpBin, NameBin}, CLabels, DurationUnit, Data},
     case ets:insert_new(Table, Tuple) of
         true ->
             maybe_set_default(Module, Registry, Name, Labels),
@@ -189,7 +189,8 @@ check_mf_exists(Table, Registry, Name, LabelValues) ->
     case ets:lookup(Table, {Registry, mf, Name}) of
         [] ->
             erlang:error({unknown_metric, Registry, Name});
-        [{_, {Labels, _}, _, _, _} = MF] ->
+        [{_, E2, _, _, _} = MF] ->
+            Labels = element(1, E2),
             LVLength = length(LabelValues),
             case length(Labels) of
                 LVLength ->
@@ -215,8 +216,7 @@ check_mf_exists(Table, Registry, Name) ->
 ?DOC(false).
 -spec mf_labels(tuple()) -> dynamic().
 mf_labels(MF) ->
-    {Labels, _} = element(2, MF),
-    Labels.
+    element(1, element(2, MF)).
 
 ?DOC(false).
 -spec mf_constant_labels(tuple()) -> dynamic().
@@ -236,7 +236,23 @@ mf_data(MF) ->
 ?DOC(false).
 -spec metrics(ets:table(), prometheus_registry:registry()) -> dynamic().
 metrics(Table, Registry) ->
-    ets:match(Table, {{Registry, mf, '$1'}, '$2', '$3', '$4', '$5'}).
+    Rows = ets:match(Table, {{Registry, mf, '$1'}, '$2', '$3', '$4', '$5'}),
+    [normalize_mf_row(Row) || Row <- Rows].
+
+normalize_mf_row([Name, {Labels, HelpBin, NameBin}, C, D, Data]) when
+    is_binary(NameBin), is_binary(HelpBin)
+->
+    [Name, {Labels, HelpBin, NameBin}, C, D, Data];
+normalize_mf_row([Name, {Labels, Help}, C, D, Data]) ->
+    %% Backward compat: old ETS data had 2-tuple; normalize on read
+    [
+        Name,
+        {Labels, prometheus_metric_spec:normalize_to_binary(Help),
+            prometheus_metric_spec:normalize_to_binary(Name)},
+        C,
+        D,
+        Data
+    ].
 
 %%====================================================================
 %% Private Parts