Packages
prometheus
6.0.2
6.1.3
6.1.2
6.1.1
6.1.0
6.0.3
6.0.2
6.0.1
6.0.0
5.1.1
5.1.0
5.0.0
4.13.0
retired
4.12.0
4.11.0
4.10.0
4.9.1
4.9.0
4.8.2
4.8.1
4.8.0
4.6.0
4.5.0
4.4.1
4.4.0
4.3.0
4.2.2
4.2.0
4.1.0
4.0.1
4.0.0
3.5.1
3.5.0
3.4.6
3.4.5
3.4.4
3.4.3
3.4.2
3.4.1
3.4.0
3.3.2
3.3.1
3.3.0
3.2.3
3.2.2
3.2.1
3.1.1
3.1.0
3.0.1
3.0.0
3.0.0-rc1
3.0.0-alpha9
3.0.0-alpha8
3.0.0-alpha7
3.0.0-alpha6
3.0.0-alpha5
3.0.0-alpha4
3.0.0-alpha3
3.0.0-alpha2
3.0.0-alpha10
3.0.0-alpha1
2.2.0
2.1.0
2.0.0
1.7.0
1.6.0
1.5.0
1.0.2
1.0.1
1.0.0
0.2.0
0.1.3
0.1.2
0.1.1
0.1.0
Prometheus.io client in Erlang
Current section
Files
Jump to
Current section
Files
src/prometheus_registry.erl
-module(prometheus_registry).
-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.
?MODULEDOC("""
A registry of Collectors.
The majority of users should use the `default`, rather than their own.
Creating a registry other than the default is primarily useful for unit tests,
or pushing a subset of metrics to the [Pushgateway](https://github.com/prometheus/pushgateway)
from batch jobs.
""").
-export([
collect/2,
collectors/1,
exists/1,
register_collector/1,
register_collector/2,
register_collectors/1,
register_collectors/2,
deregister_collector/1,
deregister_collector/2,
clear/0,
clear/1,
collector_registeredp/1,
collector_registeredp/2
]).
-export_type([
registry/0,
collect_callback/0
]).
-include("prometheus.hrl").
-type registry() :: atom().
-type collect_callback() ::
fun((registry(), prometheus_collector:collector()) -> dynamic()).
-define(TABLE, ?PROMETHEUS_REGISTRY_TABLE).
?DOC("""
Tries to find registry with the `Name`.
Assumes that registry name is always an atom.
- If `Name` is an atom `ets:lookup/2` is used
- If `Name` is an iolist performs safe search (to avoid interning atoms) and returns atom or false.
This operation is O(n).
""").
-spec exists(Name) -> Result when
Name :: atom() | iolist(),
Result :: boolean() | atom().
exists(Name) when is_atom(Name) ->
case ets:lookup(?PROMETHEUS_REGISTRY_TABLE, Name) of
[] -> false;
_ -> true
end;
exists(Name) when is_list(Name) orelse is_binary(Name) ->
try binary_to_existing_atom(iolist_to_binary(Name), utf8) of
Atom ->
case exists(Atom) of
true -> Atom;
false -> false
end
catch
error:badarg ->
false
end.
?DOC("Calls `Callback` for each collector with two arguments: `Registry` and `Collector`.").
-spec collect(Registry, Callback) -> ok when
Registry :: prometheus_registry:registry(),
Callback :: collect_callback().
collect(Registry, Callback) ->
[
Callback(Registry, Collector)
|| {_, Collector} <- ets:lookup(?TABLE, Registry)
],
ok.
?DOC("Returns collectors registered in `Registry`.").
-spec collectors(Registry :: prometheus_registry:registry()) ->
[Collector :: prometheus_collector:collector()].
collectors(Registry) ->
[Collector || {_, Collector} <- ets:lookup(?TABLE, Registry)].
?DOC(#{equiv => register_collector(default, Collector)}).
-spec register_collector(Collector :: prometheus_collector:collector()) -> ok.
register_collector(Collector) ->
register_collector(default, Collector).
?DOC("Register a collector.").
-spec register_collector(Registry, Collector) -> ok when
Registry :: prometheus_registry:registry(),
Collector :: prometheus_collector:collector().
register_collector(Registry, Collector) ->
ets:insert(?TABLE, {Registry, Collector}),
ok.
-spec register_collectors(Collectors :: [prometheus_collector:collector()]) ->
ok.
?DOC(#{equiv => register_collectors(default, Collectors)}).
register_collectors(Collectors) ->
register_collectors(default, Collectors).
?DOC("Registers collectors list.").
-spec register_collectors(Registry, Collectors) -> ok when
Registry :: prometheus_registry:registry(),
Collectors :: [prometheus_collector:collector()].
register_collectors(Registry, Collectors) ->
[register_collector(Registry, Collector) || Collector <- Collectors],
ok.
?DOC(#{equiv => deregister_collector(default, Collector)}).
-spec deregister_collector(Collector :: prometheus_collector:collector()) -> ok.
deregister_collector(Collector) ->
deregister_collector(default, Collector).
?DOC("Unregisters a collector.").
-spec deregister_collector(Registry, Collector) -> ok when
Registry :: prometheus_registry:registry(),
Collector :: prometheus_collector:collector().
deregister_collector(Registry, Collector) ->
ets:delete_object(?TABLE, {Registry, Collector}),
Collector:deregister_cleanup(Registry),
ok.
?DOC(#{equiv => clear(default)}).
-spec clear() -> ok.
clear() ->
clear(default).
?DOC("Unregisters all collectors.").
-spec clear(Registry :: prometheus_registry:registry()) -> ok.
clear(Registry) ->
[
Collector:deregister_cleanup(Registry)
|| {_, Collector} <- ets:take(?TABLE, Registry)
],
ok.
?DOC(#{equiv => collector_registeredp(default, Collector)}).
-spec collector_registeredp(Collector) -> boolean() when
Collector :: prometheus_collector:collector().
collector_registeredp(Collector) ->
collector_registeredp(default, Collector).
?DOC("Checks whether `Collector` is registered.").
-spec collector_registeredp(Registry, Collector) -> boolean() when
Registry :: prometheus_registry:registry(),
Collector :: prometheus_collector:collector().
collector_registeredp(Registry, Collector) ->
case ets:match(?TABLE, {Registry, Collector}) of
[] -> false;
_ -> true
end.