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,35 +57,35 @@ 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 format_into_binary/2, <<>>).
+
+format_into_binary(Acc, Data) ->
+    <<Acc/binary, Data/binary>>.
 
 ?DOC("""
-Escapes the backslash (\\), double-quote (\"), and line feed (\\n) characters
+Formats `Registry` using the latest text format, passing the binary data for
+each collector to the format function.
 """).
--spec escape_label_value(binary() | iolist()) -> binary().
-escape_label_value(LValue) when is_binary(LValue) ->
-    case has_special_char(LValue) of
-        true ->
-            escape_string(fun escape_label_char/1, LValue);
-        false ->
-            LValue
-    end;
-escape_label_value(LValue) when is_list(LValue) ->
-    escape_label_value(iolist_to_binary(LValue));
-escape_label_value(Value) ->
-    erlang:error({invalid_value, Value}).
+-spec format_into(
+    Registry :: prometheus_registry:registry(), fun((term(), binary()) -> term()), term()
+) -> term().
+format_into(Registry, Fmt, State) ->
+    State1 = lists:foldl(
+        format_into_collector_fn(Registry, Fmt), State, prometheus_registry:collectors(Registry)
+    ),
+    Fmt(State1, <<"\n">>).
+
+format_into_collector_fn(Registry, Fmt) ->
+    fun(Collector, Acc) ->
+        put(?MODULE, Acc),
+        prometheus_collector:collect_mf(
+            Registry, Collector, format_into_create_mf_callback_fn(Fmt)
+        ),
+        erase(?MODULE)
+    end.
 
-registry_collect_callback(Fd, Registry, Collector) ->
-    Callback = fun(#'MetricFamily'{name = Name0, help = Help, type = Type, metric = Metrics}) ->
+format_into_create_mf_callback_fn(Fmt) ->
+    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),
@@ -100,12 +100,25 @@ registry_collect_callback(Fd, Registry, Collector) ->
             (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).
+        Bin = render_metrics(Prologue, Name, Metrics),
+        put(?MODULE, Fmt(Bin, erase(?MODULE)))
+    end.
+
+?DOC("""
+Escapes the backslash (\\), double-quote (\"), and line feed (\\n) characters
+""").
+-spec escape_label_value(binary() | iolist()) -> binary().
+escape_label_value(LValue) when is_binary(LValue) ->
+    case has_special_char(LValue) of
+        true ->
+            escape_string(fun escape_label_char/1, LValue);
+        false ->
+            LValue
+    end;
+escape_label_value(LValue) when is_list(LValue) ->
+    escape_label_value(iolist_to_binary(LValue));
+escape_label_value(Value) ->
+    erlang:error({invalid_value, Value}).
 
 render_metrics(Bytes, _Name, []) ->
     Bytes;