break: Improve startup time of the prometheus application

This means that by default prometheus won't try to find all loaded
modules implementing a behaviour, as this can be a very expensive
operation (taking many seconds as has been seen in the field). If such
behaviour was desired, it'd require explicitly setting `all_loaded` for
instrumeters and collectors. The default is the most sane behaviour.

Author: NelsonVides

README.md

@@ -182,12 +182,12 @@ Histogram also accepts `buckets` option. Please refer to respective modules docs
 
 ### Advanced
 
-You will need these modules only if you're writing custom collector for app/lib that can't be instrumented directly.
+You will need these modules only if you're writing a custom collector for an app/lib that can't be instrumented directly.
 
 - [`prometheus_collector`](https://github.com/deadtrickster/prometheus.erl/blob/master/doc/prometheus_collector.md) - common interface for collectors;
 - [`prometheus_format`](https://github.com/deadtrickster/prometheus.erl/blob/master/doc/prometheus_format.md) - common interface for exposition formats;
 - [`prometheus_model_helpers`](https://github.com/deadtrickster/prometheus.erl/blob/master/doc/prometheus_model_helpers.md) - provides API for working with underlying Prometheus models.
-You'll use that if you want to create custom collector.
+You'll use that if you want to create a custom collector.
 
 ## Build
 
@@ -198,29 +198,27 @@ You'll use that if you want to create custom collector.
 ## Configuration
 
 Prometheus.erl supports standard Erlang app configuration.
-- `collectors` - List of custom collectors modules to be registered automatically. If undefined list of all modules implementing `prometheus_collector` behaviour will be used.
-- `default_metrics` - List of metrics to be registered during app startup. Metric format: `{Type, Spec}` where `Type` is a metric type (counter, gauge, etc), `Spec` is a list to be passed to `Metric:declare/1`. Deprecated format `{Registry, Metric, Spec}` also supported.
-
-Collectors config also supports "alias" option `default`. When used these collectors will be registered:
-<pre>
-prometheus_boolean,
-prometheus_counter,
-prometheus_gauge,
-prometheus_histogram,
-prometheus_mnesia_collector,
-prometheus_summary,
-prometheus_vm_memory_collector,
-prometheus_vm_statistics_collector,
-prometheus_vm_system_info_collector
-</pre>
+- `collectors` - List of custom collectors modules to be registered automatically.
+    Can be `all_loaded` in order to find all modules implementing the `prometheus_collector` behaviour.
+    Supports an "alias" option `default`, which will append all default collectors implemented in this library.
+    If undefined, the default collectors implemented in this library will be used.
+- `instrumenters` - List of custom instrumenter modules to be registered automatically.
+    Can be `all_loaded` in order to find all modules implementing the `prometheus_instrumenter` behaviour.
+    If undefined, none will be loaded.
+- `default_metrics` - List of metrics to be registered during app startup.
+    Metric format: `{Type, Spec}` where `Type` is a metric type (counter, gauge, etc),
+    `Spec` is a list to be passed to `Metric:declare/1`.
+    Deprecated format `{Registry, Metric, Spec}` also supported.
+
 ## Collectors & Exporters Conventions
 
 ### Configuration
 
 All 3d-party libraries should be configured via `prometheus` app env.
 
-Exproters are responsible for maintianing scrape endpoint.
-Exporters usually tightly coupled with web server and are singletons. They should understand these keys:
+Exporters are responsible for maintaining scrape endpoint.
+Exporters are usually tightly coupled with the web server and are singletons.
+They should understand these keys:
  - `path` - url for scraping;
  - `format` - scrape format as module name i.e. `prometheus_text_format` or `prometheus_protobuf_format`.
 Exporter-specific options should be under `<exporter_name>_exporter` for erlang or `<Exporter_name>Exporter` for Elixir i.e. `PlugsExporter` or `elli_exporter`

src/prometheus_collector.erl

@@ -128,7 +128,8 @@ Called when collector is deregistered. If collector is stateful you can put clea
 enabled_collectors() ->
     lists:usort(
         case application:get_env(prometheus, collectors) of
-            undefined -> all_known_collectors();
+            undefined -> ?DEFAULT_COLLECTORS;
+            {ok, all_loaded} -> all_known_collectors();
             {ok, Collectors} -> catch_default_collectors(Collectors)
         end
     ).

src/prometheus_instrumenter.erl

@@ -19,7 +19,8 @@
 -spec enabled_instrumenters() -> [instrumenter()].
 enabled_instrumenters() ->
     case application:get_env(prometheus, instrumenters) of
-        undefined -> all_known_instrumenters();
+        undefined -> [];
+        {ok, all_loaded} -> all_known_instrumenters();
         {ok, Instrumenters} -> Instrumenters
     end.
 

src/prometheus_misc.erl

@@ -20,41 +20,30 @@
 %% Retrieves a list of modules that implement a specified behaviour.
 -spec behaviour_modules(Behaviour :: atom()) -> [module()].
 behaviour_modules(Behaviour) ->
-    [
-        Module
-     || {Module, Behaviours} <-
-            all_module_attributes(behaviour),
-        lists:member(Behaviour, Behaviours)
-    ].
+    Applications = application:loaded_applications(),
+    Modules = lists:flatmap(fun get_modules_for_app/1, Applications),
+    Targets = lists:usort(Modules),
+    extract_behaviour_from_modules(Targets, Behaviour).
 
-all_module_attributes(Name) ->
-    Targets =
-        lists:usort(
-            lists:append(
-                [
-                    [{App, Module} || Module <- Modules]
-                 || {App, _, _} <- application:loaded_applications(),
-                    {ok, Modules} <- [application:get_key(App, modules)]
-                ]
-            )
-        ),
-    lists:foldl(
-        fun({_App, Module}, Acc) ->
-            case
-                lists:append([
-                    Atts
-                 || {N, Atts} <- module_attributes(Module),
-                    N =:= Name
-                ])
-            of
-                [] -> Acc;
-                Atts -> [{Module, Atts} | Acc]
-            end
-        end,
-        [],
-        Targets
-    ).
+-spec get_modules_for_app({atom(), string(), string()}) -> [module()].
+get_modules_for_app({App, _, _}) ->
+    case application:get_key(App, modules) of
+        {ok, Modules} -> Modules;
+        _ -> []
+    end.
+
+-spec extract_behaviour_from_modules([module()], Behaviour :: atom()) -> [module()].
+extract_behaviour_from_modules(Modules, Behaviour) ->
+    Filter = fun(Module) -> does_module_implement_behaviour(Module, Behaviour) end,
+    lists:filter(Filter, Modules).
+
+-spec does_module_implement_behaviour(Module :: module(), Behaviour :: atom()) -> boolean().
+does_module_implement_behaviour(Module, Behaviour) ->
+    Attributes = module_attributes(Module),
+    Behaviours = [Atts || {N, Atts} <- Attributes, (N =:= behaviour orelse N =:= behavior)],
+    lists:member(Behaviour, lists:flatten(Behaviours)).
 
+-spec module_attributes(atom()) -> [{atom(), any()}] | [].
 module_attributes(Module) ->
     try
         Module:module_info(attributes)

test/eunit/prometheus_collector_tests.erl

@@ -19,14 +19,20 @@
 
 collector_setup_test() ->
     prometheus:start(),
-    application:set_env(prometheus, collectors, [qwe]),
     try
+        application:set_env(prometheus, collectors, all_loaded),
+        ?assertMatch(?DEFAULT_COLLECTORS, prometheus_collector:enabled_collectors())
+    after
+        application:unset_env(prometheus, collectors)
+    end,
+    try
+        application:set_env(prometheus, collectors, [qwe]),
         ?assertMatch([qwe], prometheus_collector:enabled_collectors())
     after
         application:unset_env(prometheus, collectors)
     end,
-    application:set_env(prometheus, collectors, [qwe, default]),
     try
+        application:set_env(prometheus, collectors, [qwe, default]),
         C1 = ?DEFAULT_COLLECTORS ++ [qwe],
         ?assertMatch(C1, prometheus_collector:enabled_collectors())
     after

test/eunit/prometheus_instrumenter_tests.erl

@@ -4,14 +4,18 @@
 
 instrumenter_setup_test() ->
     prometheus:start(),
-    ?assertNotMatch(undefined, ets:info(prometheus_instrumenter_tests)),
-    application:set_env(prometheus, instrumenters, [qwe]),
+    ?assertMatch(undefined, ets:info(prometheus_instrumenter_tests)),
     try
+        application:set_env(prometheus, instrumenters, [qwe]),
         ?assertMatch([qwe], prometheus_instrumenter:enabled_instrumenters())
     after
         application:unset_env(prometheus, instrumenters)
     end,
-    ?assertMatch(
-        [prometheus_test_instrumenter],
-        prometheus_instrumenter:enabled_instrumenters()
-    ).
+    try
+        application:set_env(prometheus, instrumenters, all_loaded),
+        Expected = [prometheus_test_instrumenter],
+        ?assertMatch(Expected, prometheus_instrumenter:enabled_instrumenters())
+    after
+        application:unset_env(prometheus, instrumenters)
+    end,
+    ?assertMatch([], prometheus_instrumenter:enabled_instrumenters()).