prometheus_text_format: Eliminate ram_file, add format_into/3

Building on the work in the parent commit, now that the data being
passed to the `ram_file` is a binary, we can instead build the entire
output gradually within the process. We pay in terms of I/O overhead
from writing and then reading from the `ram_file` since `ram_file` is a
port - all data is passed between the VM and the port driver. The memory
consumed by a port driver is also invisible to the VM's allocator, so
large port driver resource usage should be avoided where possible.

Instead this change refactors the `registry_collect_callback` to fold
over collectors and build an accumulator. The `create_mf` callback's
return of `ok` forces us to store this rather than pass and return it.
So it's a little less hygienic but is more efficient than passing data
in/out of a port.

This also introduces a function `format_into/3` which can use this
folding function directly. This can be used to avoid collecting the
entire response in one binary. Instead the response can be streamed
with `cowboy_req:stream_body/3` for example.

Author: the-mikedavis

src/formats/prometheus_text_format.erl

@@ -26,7 +26,7 @@ http_request_duration_milliseconds_sum{method=\"post\"} 4350
 ```
 """).
 
--export([content_type/0, format/0, format/1, render_labels/1, escape_label_value/1]).
+-export([content_type/0, format/0, format/1, format_into/3, render_labels/1, escape_label_value/1]).
 
 -ifdef(TEST).
 -export([escape_metric_help/1]).
@@ -57,16 +57,46 @@ format() ->
 ?DOC("Formats `Registry` using the latest text format.").
 -spec format(Registry :: prometheus_registry:registry()) -> binary().
 format(Registry) ->
-    {ok, Fd} = ram_file:open("", [write, read, binary]),
-    Callback = fun(_, Collector) ->
-        registry_collect_callback(Fd, Registry, Collector)
-    end,
-    prometheus_registry:collect(Registry, Callback),
-    file:write(Fd, "\n"),
-    {ok, Size} = ram_file:get_size(Fd),
-    {ok, Str} = file:pread(Fd, 0, Size),
-    ok = file:close(Fd),
-    Str.
+    format_into(Registry, <<>>, fun(Data, Acc) -> <<Acc/binary, Data/binary>> end).
+
+?DOC("""
+Formats `Registry` using the latest text format, passing the binary data for
+each collector to the format function.
+""").
+-spec format_into(Registry :: prometheus_registry:registry(), term(), fun(
+    (binary(), term()) -> term()
+)) -> term().
+format_into(Registry, State, Fmt) ->
+    State1 = lists:foldl(
+        fun(Collector, Acc) ->
+            put(?MODULE, Acc),
+            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"
+                >>,
+                Bin = render_metrics(Name, Metrics, Prologue),
+                put(?MODULE, Fmt(Bin, erase(?MODULE)))
+            end,
+            prometheus_collector:collect_mf(Registry, Collector, Callback),
+            erase(?MODULE)
+        end,
+        State,
+        prometheus_registry:collectors(Registry)
+    ),
+    Fmt(<<"\n">>, State1).
 
 ?DOC("""
 Escapes the backslash (\\), double-quote (\"), and line feed (\\n) characters
@@ -84,29 +114,6 @@ escape_label_value(LValue) when is_list(LValue) ->
 escape_label_value(Value) ->
     erlang:error({invalid_value, Value}).
 
-registry_collect_callback(Fd, Registry, Collector) ->
-    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).
-
 render_metrics(_Name, [], Bytes) ->
     Bytes;
 render_metrics(Name, [Metric | Rest], Bytes) ->