prometheus_text_format: Optimize binary construction

The formatting callback for a registry can build each metrics family as
a single binary in order to reduce garbage. This mainly involves passing
the accumulator binary through all functions that append to it.

It's more efficient to append to the resulting binary than to allocate
smaller binaries and then append them. For example:

    <<Blob/binary, Name/binary, "_", Suffix/binary>>.
    %% versus
    Combined = <<Name/binary, "_", Suffix/binary>>,
    <<Blob/binary, Combined/binary>>.

The first expression generates less garbage than the second. A good
example of this was the `add_brackets/1` function which was inlined.
Inlining does not turn the first expression (above) into the second
according to the compiler unfortunately, so we pay the cost of creating
a binary with brackets and then formatting that into the larger blob,
rather than formatting in just by copying. This change manually inlines
`add_brackets/1` into its caller `render_series/4`.

This change also changes some list strings into binaries. Especially for
ASCII, strings binaries are _far_ more compact than lists. Lists need
two words per ASCII character - one for the character and one for the
tail pointer. So it's like UTF-32 but worse, basically UTF-128 on a 64
bit machine. ASCII or UTF-8 text in binaries takes one byte per
character in the binary's array, plus a word or two of metadata. E.g.
`<<"hello">>` allocates three words while `"hello"` allocates ten.

Author: the-mikedavis

src/formats/prometheus_text_format.erl

@@ -29,13 +29,13 @@ http_request_duration_milliseconds_sum{method=\"post\"} 4350
 -export([content_type/0, format/0, format/1, render_labels/1, escape_label_value/1]).
 
 -ifdef(TEST).
--export([escape_metric_help/1, emit_mf_prologue/2, emit_mf_metrics/2]).
+-export([escape_metric_help/1]).
 -endif.
 
 -include("prometheus_model.hrl").
 
 -behaviour(prometheus_format).
--compile({inline, [add_brackets/1, render_label_pair/1]}).
+-compile({inline, [render_label_pair/1]}).
 
 ?DOC("""
 Returns content type of the latest \[text format](https://bit.ly/2cxSuJP).
@@ -85,50 +85,40 @@ escape_label_value(Value) ->
     erlang:error({invalid_value, Value}).
 
 registry_collect_callback(Fd, Registry, Collector) ->
-    Callback = fun(MF) ->
-        emit_mf_prologue(Fd, MF),
-        emit_mf_metrics(Fd, MF)
+    Callback = fun(#'MetricFamily'{name = Name0, help = Help, type = Type, metric = Metrics}) ->
+        %% eagerly convert the name to a binary so we can copy more efficiently
+        %% in `render_metrics/3`
+        Name = iolist_to_binary(Name0),
+        Prologue = <<
+            "# TYPE ",
+            Name/binary,
+            " ",
+            (string_type(Type))/binary,
+            "\n# HELP ",
+            Name/binary,
+            " ",
+            (escape_metric_help(Help))/binary,
+            "\n"
+        >>,
+        %% file:write/2 is an expensive operation, as it goes through a port driver.
+        %% Instead a large chunk of bytes is being collected here, in a
+        %% way that triggers binary append optimization in ERTS.
+        file:write(Fd, render_metrics(Name, Metrics, Prologue))
     end,
     prometheus_collector:collect_mf(Registry, Collector, Callback).
 
-?DOC(false).
--spec emit_mf_prologue(Fd :: file:fd(), prometheus_model:'MetricFamily'()) -> ok.
-emit_mf_prologue(Fd, #'MetricFamily'{name = Name, help = Help, type = Type}) ->
-    Bytes = [
-        "# TYPE ",
-        Name,
-        " ",
-        string_type(Type),
-        "\n# HELP ",
-        Name,
-        " ",
-        escape_metric_help(Help),
-        "\n"
-    ],
-    file:write(Fd, Bytes).
+render_metrics(_Name, [], Bytes) ->
+    Bytes;
+render_metrics(Name, [Metric | Rest], Bytes) ->
+    render_metrics(Name, Rest, render_metric(Bytes, Name, Metric)).
 
-?DOC(false).
--spec emit_mf_metrics(file:fd(), prometheus_model:'MetricFamily'()) -> ok | {error, term()}.
-emit_mf_metrics(Fd, #'MetricFamily'{name = Name, metric = Metrics}) ->
-    %% file:write/2 is an expensive operation, as it goes through a port driver.
-    %% Instead a large chunk of bytes is being collected here, in a
-    %% way that triggers binary append optimization in ERTS.
-    Bytes = lists:foldl(
-        fun(Metric, Blob) ->
-            <<Blob/binary, (render_metric(Name, Metric))/binary>>
-        end,
-        <<>>,
-        Metrics
-    ),
-    file:write(Fd, Bytes).
-
-render_metric(Name, #'Metric'{label = Labels, counter = #'Counter'{value = Value}}) ->
-    render_series(Name, render_labels(Labels), Value);
-render_metric(Name, #'Metric'{label = Labels, gauge = #'Gauge'{value = Value}}) ->
-    render_series(Name, render_labels(Labels), Value);
-render_metric(Name, #'Metric'{label = Labels, untyped = #'Untyped'{value = Value}}) ->
-    render_series(Name, render_labels(Labels), Value);
-render_metric(Name, #'Metric'{
+render_metric(Bytes0, Name, #'Metric'{label = Labels, counter = #'Counter'{value = Value}}) ->
+    render_series(Bytes0, Name, render_labels(Labels), Value);
+render_metric(Bytes0, Name, #'Metric'{label = Labels, gauge = #'Gauge'{value = Value}}) ->
+    render_series(Bytes0, Name, render_labels(Labels), Value);
+render_metric(Bytes0, Name, #'Metric'{label = Labels, untyped = #'Untyped'{value = Value}}) ->
+    render_series(Bytes0, Name, render_labels(Labels), Value);
+render_metric(Bytes0, Name, #'Metric'{
     label = Labels,
     summary = #'Summary'{
         sample_count = Count,
@@ -137,12 +127,13 @@ render_metric(Name, #'Metric'{
     }
 }) ->
     LString = render_labels(Labels),
-    Bytes1 = render_series([Name, "_count"], LString, Count),
-    Bytes2 = <<Bytes1/binary, (render_series([Name, "_sum"], LString, Sum))/binary>>,
+    Bytes1 = render_series(Bytes0, <<Name/binary, "_count">>, LString, Count),
+    Bytes2 = render_series(Bytes1, <<Name/binary, "_sum">>, LString, Sum),
     Bytes3 = lists:foldl(
         fun(#'Quantile'{quantile = QN, value = QV}, Blob) ->
-            Val = render_series(
-                [Name],
+            render_series(
+                Blob,
+                Name,
                 render_labels(
                     [
                         LString,
@@ -153,14 +144,13 @@ render_metric(Name, #'Metric'{
                     ]
                 ),
                 QV
-            ),
-            <<Blob/binary, Val/binary>>
+            )
         end,
         Bytes2,
         Quantiles
     ),
     Bytes3;
-render_metric(Name, #'Metric'{
+render_metric(Bytes0, Name, #'Metric'{
     label = Labels,
     histogram = #'Histogram'{
         sample_count = Count,
@@ -172,33 +162,34 @@ render_metric(Name, #'Metric'{
     LString = render_labels(Labels),
     Bytes1 = lists:foldl(
         fun(Bucket, Blob) ->
-            <<Blob/binary, (emit_histogram_bucket(Name, LString, Bucket))/binary>>
+            emit_histogram_bucket(Blob, Name, LString, Bucket)
         end,
-        <<>>,
+        Bytes0,
         Buckets
     ),
-    Bytes2 = <<Bytes1/binary, (render_series([Name, "_count"], LString, Count))/binary>>,
-    Bytes3 = <<Bytes2/binary, (render_series([Name, "_sum"], LString, Sum))/binary>>,
+    Bytes2 = render_series(Bytes1, <<Name/binary, "_count">>, LString, Count),
+    Bytes3 = render_series(Bytes2, <<Name/binary, "_sum">>, LString, Sum),
     Bytes3.
 
-emit_histogram_bucket(Name, LString, #'Bucket'{cumulative_count = BCount, upper_bound = BBound}) ->
+emit_histogram_bucket(Bytes0, Name, LString, #'Bucket'{cumulative_count = BCount, upper_bound = BBound}) ->
     BLValue = bound_to_label_value(BBound),
     render_series(
-        [Name, "_bucket"],
+        Bytes0,
+        <<Name/binary, "_bucket">>,
         render_labels([LString, #'LabelPair'{name = "le", value = BLValue}]),
         BCount
     ).
 
 string_type('COUNTER') ->
-    "counter";
+    <<"counter">>;
 string_type('GAUGE') ->
-    "gauge";
+    <<"gauge">>;
 string_type('SUMMARY') ->
-    "summary";
+    <<"summary">>;
 string_type('HISTOGRAM') ->
-    "histogram";
+    <<"histogram">>;
 string_type('UNTYPED') ->
-    "untyped".
+    <<"untyped">>.
 
 %% binary() in spec means 0 or more already rendered labels (name,
 %% escaped value), joined with "," in between
@@ -233,26 +224,18 @@ render_label_pair(B) when is_binary(B) ->
 render_label_pair(#'LabelPair'{name = Name, value = Value}) ->
     <<(iolist_to_binary(Name))/binary, "=\"", (escape_label_value(Value))/binary, "\"">>.
 
-add_brackets(<<>>) ->
-    <<>>;
-add_brackets(LString) ->
-    <<"{", LString/binary, "}">>.
+render_series(Bytes, Name, <<>>, Value) ->
+    render_value(<<Bytes/binary, Name/binary, " ">>, Value);
+render_series(Bytes, Name, LString, Value) ->
+    render_value(<<Bytes/binary, Name/binary, "{", LString/binary, "} ">>, Value).
 
-render_series(Name, LString, undefined) ->
-    <<(iolist_to_binary(Name))/binary, (add_brackets(LString))/binary, " NaN\n">>;
-render_series(Name, LString, Value) when is_integer(Value) ->
-    <<
-        (iolist_to_binary(Name))/binary,
-        (add_brackets(LString))/binary,
-        " ",
-        (integer_to_binary(Value))/binary,
-        "\n"
-    >>;
-render_series(Name, LString, Value) ->
+render_value(Bytes, undefined) ->
+    <<Bytes/binary, "NaN\n">>;
+render_value(Bytes, Value) when is_integer(Value) ->
+    <<Bytes/binary, (integer_to_binary(Value))/binary, "\n">>;
+render_value(Bytes, Value) ->
     <<
-        (iolist_to_binary(Name))/binary,
-        (add_brackets(LString))/binary,
-        " ",
+        Bytes/binary,
         (iolist_to_binary(io_lib:format("~p", [Value])))/binary,
         "\n"
     >>.