ft:修改

include/rum.hrl

@@ -54,9 +54,9 @@
       ?EMERGENCY -> emergency
    end).
 
--define(RunShouldLog(Sink, Level), (rumUtil:level_to_num(Level) band element(1, lager_config:get({Sink, loglevel}, {?LOG_NONE, []}))) /= 0).
+-define(RunShouldLog(Sink, Level), (rumUtil:level_to_num(Level) band element(1, rumConfig:get({Sink, loglevel}, {?LOG_NONE, []}))) /= 0).
 
--define(RunShouldLog(Level), (rumUtil:level_to_num(Level) band element(1, lager_config:get(loglevel, {?LOG_NONE, []}))) /= 0).
+-define(RunShouldLog(Level), (rumUtil:level_to_num(Level) band element(1, rumConfig:get(loglevel, {?LOG_NONE, []}))) /= 0).
 
 -define(RunNotify(Level, Pid, Format, Args),
    gen_event:notify(lager_event, {log, lager_msg:new(io_lib:format(Format, Args), Level, [{pid, Pid}, {line, ?LINE}, {file, ?FILE}, {module, ?MODULE}], [])})).

src/eRum.erl

@@ -119,7 +119,7 @@ md(_) ->
 %% see lager_transform (lines 173-216)
 dispatch_log(Sink, Severity, Metadata, Format, Args, Size, Safety) when is_atom(Severity) ->
    SeverityAsInt = rumUtil:level_to_num(Severity),
-   case {whereis(Sink), whereis(?RumDefSink), lager_config:get({Sink, loglevel}, {?LOG_NONE, []})} of
+   case {whereis(Sink), whereis(?RumDefSink), rumConfig:get({Sink, loglevel}, {?LOG_NONE, []})} of
       {undefined, undefined, _} -> {error, lager_not_running};
       {undefined, _LagerEventPid0, _} -> {error, {sink_not_configured, Sink}};
       {SinkPid, _LagerEventPid1, {Level, Traces}} when Safety =:= safe andalso ((Level band SeverityAsInt) /= 0 orelse Traces /= []) ->
@@ -151,7 +151,7 @@ do_log_impl(Severity, Metadata, Format, Args, SeverityAsInt, LevelThreshold, Tra
                end,
          LagerMsg = lager_msg:new(Msg,
             Severity, Metadata, Destinations),
-         case lager_config:get({Sink, async}, false) of
+         case rumConfig:get({Sink, async}, false) of
             true ->
                gen_event:notify(SinkPid, {log, LagerMsg});
             false ->
@@ -240,7 +240,7 @@ trace_file(File, Filter, Level, Options) ->
    FileName = rumUtil:expand_path(File),
    case validate_trace_filters(Filter, Level, {lager_file_backend, FileName}) of
       {Sink, {ok, Trace}} ->
-         Handlers = lager_config:global_get(handlers, []),
+         Handlers = rumConfig:global_get(handlers, []),
          %% check if this file backend is already installed
          Res = case rumUtil:find_file(FileName, Handlers) of
                   false ->
@@ -254,7 +254,7 @@ trace_file(File, Filter, Level, Options) ->
                      HandlerInfo =
                         lager_app:start_handler(Sink, {lager_file_backend, FileName},
                            LogFileConfig),
-                     lager_config:global_set(handlers, [HandlerInfo | Handlers]),
+                     rumConfig:global_set(handlers, [HandlerInfo | Handlers]),
                      {ok, installed};
                   {_Watcher, _Handler, Sink} ->
                      {ok, exists};
@@ -314,20 +314,20 @@ stop_trace({Backend, Filter, Level}) ->
 %% and when they come back from validation, they're
 %% `{Filter, Level, Backend}'
 stop_trace_int({_Filter, _Level, Backend} = Trace, Sink) ->
-   {Level, Traces} = lager_config:get({Sink, loglevel}),
+   {Level, Traces} = rumConfig:get({Sink, loglevel}),
    NewTraces = lists:delete(Trace, Traces),
    _ = rumUtil:trace_filter([element(1, T) || T <- NewTraces]),
    %MinLevel = minimum_loglevel(get_loglevels() ++ get_trace_levels(NewTraces)),
-   lager_config:set({Sink, loglevel}, {Level, NewTraces}),
+   rumConfig:set({Sink, loglevel}, {Level, NewTraces}),
    case get_loglevel(Sink, Backend) of
       none ->
          %% check no other traces point here
          case lists:keyfind(Backend, 3, NewTraces) of
             false ->
                gen_event:delete_handler(Sink, Backend, []),
-               lager_config:global_set(handlers,
+               rumConfig:global_set(handlers,
                   lists:keydelete(Backend, 1,
-                     lager_config:global_get(handlers)));
+                     rumConfig:global_get(handlers)));
             _ ->
                ok
          end;
@@ -342,13 +342,13 @@ list_all_sinks() ->
          sets:add_element(Sink, Set)
                   end,
          sets:new(),
-         lager_config:global_get(handlers, []))).
+         rumConfig:global_get(handlers, []))).
 
 clear_traces_by_sink(Sinks) ->
    lists:foreach(fun(S) ->
       {Level, _Traces} =
-         lager_config:get({S, loglevel}),
-      lager_config:set({S, loglevel},
+         rumConfig:get({S, loglevel}),
+      rumConfig:set({S, loglevel},
          {Level, []})
                  end,
       Sinks).
@@ -360,10 +360,10 @@ clear_trace_by_destination(ID) ->
 
 
 clear_all_traces() ->
-   Handlers = lager_config:global_get(handlers, []),
+   Handlers = rumConfig:global_get(handlers, []),
    clear_traces_by_sink(list_all_sinks()),
    _ = rumUtil:trace_filter(none),
-   lager_config:global_set(handlers,
+   rumConfig:global_set(handlers,
       lists:filter(
          fun({Handler, _Watcher, Sink}) ->
             case get_loglevel(Sink, Handler) of
@@ -377,14 +377,14 @@ clear_all_traces() ->
 
 find_traces(Sinks) ->
    lists:foldl(fun(S, Acc) ->
-      {_Level, Traces} = lager_config:get({S, loglevel}),
+      {_Level, Traces} = rumConfig:get({S, loglevel}),
       Acc ++ lists:map(fun(T) -> {S, T} end, Traces)
                end,
       [],
       Sinks).
 
 status() ->
-   Handlers = lager_config:global_get(handlers, []),
+   Handlers = rumConfig:global_get(handlers, []),
    Sinks = lists:sort(list_all_sinks()),
    Traces = find_traces(Sinks),
    TraceCount = case length(Traces) of
@@ -508,12 +508,12 @@ set_loghwm(Sink, Handler, Ident, Hwm) when is_integer(Hwm) ->
 
 %% @private
 add_trace_to_loglevel_config(Trace, Sink) ->
-   {MinLevel, Traces} = lager_config:get({Sink, loglevel}),
+   {MinLevel, Traces} = rumConfig:get({Sink, loglevel}),
    case lists:member(Trace, Traces) of
       false ->
          NewTraces = [Trace | Traces],
          _ = rumUtil:trace_filter([element(1, T) || T <- NewTraces]),
-         lager_config:set({Sink, loglevel}, {MinLevel, [Trace | Traces]});
+         rumConfig:set({Sink, loglevel}, {MinLevel, [Trace | Traces]});
       _ ->
          ok
    end.
@@ -524,9 +524,9 @@ update_loglevel_config(error_logger) ->
    %% utility that error_logger_lager_h attaches to
    true;
 update_loglevel_config(Sink) ->
-   {_, Traces} = lager_config:get({Sink, loglevel}, {ignore_me, []}),
+   {_, Traces} = rumConfig:get({Sink, loglevel}, {ignore_me, []}),
    MinLog = minimum_loglevel(get_loglevels(Sink)),
-   lager_config:set({Sink, loglevel}, {MinLog, Traces}).
+   rumConfig:set({Sink, loglevel}, {MinLog, Traces}).
 
 %% @private
 minimum_loglevel(Levels) ->
@@ -668,7 +668,7 @@ pr_stacktrace(Stacktrace, {Class, Reason}) ->
    end.
 
 rotate_sink(Sink) ->
-   Handlers = lager_config:global_get(handlers),
+   Handlers = rumConfig:global_get(handlers),
    RotateHandlers = lists:filtermap(
       fun({Handler, _, S}) when S == Sink -> {true, {Handler, Sink}};
          (_) -> false
@@ -678,7 +678,7 @@ rotate_sink(Sink) ->
 
 rotate_all() ->
    rotate_handlers(lists:map(fun({H, _, S}) -> {H, S} end,
-      lager_config:global_get(handlers))).
+      rumConfig:global_get(handlers))).
 
 
 rotate_handlers(Handlers) ->
@@ -686,7 +686,7 @@ rotate_handlers(Handlers) ->
 
 
 rotate_handler(Handler) ->
-   Handlers = lager_config:global_get(handlers),
+   Handlers = rumConfig:global_get(handlers),
    case lists:keyfind(Handler, 1, Handlers) of
       {Handler, _, Sink} -> rotate_handler(Handler, Sink);
       false -> ok

src/eRum_app.erl

@@ -1,16 +1,17 @@
 -module(eRum_app).
 
 -behaviour(application).
+
 -include("rum.hrl").
--ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
--endif.
--export([start/0,
-   start/2,
-   start_handler/3,
-   configure_sink/2,
-   stop/1,
-   boot/1]).
+
+-export([
+   start/0
+   , start/2
+   , start_handler/3
+   , configure_sink/2
+   , stop/1
+   , boot/1
+]).
 
 %% The `application:get_env/3` compatibility wrapper was useful
 %% for other modules in r15 and before
@@ -19,15 +20,10 @@
 -define(FILENAMES, '__lager_file_backend_filenames').
 -define(THROTTLE, lager_backend_throttle).
 -define(DEFAULT_HANDLER_CONF,
-   [{lager_console_backend, [{level, info}]},
-      {lager_file_backend,
-         [{file, "log/error.log"}, {level, error},
-            {size, 10485760}, {date, "$D0"}, {count, 5}]
-      },
-      {lager_file_backend,
-         [{file, "log/console.log"}, {level, info},
-            {size, 10485760}, {date, "$D0"}, {count, 5}]
-      }
+   [
+      {lager_console_backend, [{level, info}]},
+      {lager_file_backend, [{file, "log/error.log"}, {level, error}, {size, 10485760}, {date, "$D0"}, {count, 5}]},
+      {lager_file_backend, [{file, "log/console.log"}, {level, info}, {size, 10485760}, {date, "$D0"}, {count, 5}]}
    ]).
 
 start() ->
@@ -41,14 +37,12 @@ start_throttle(Sink, Threshold, Window) ->
 determine_async_behavior(_Sink, undefined, _Window) ->
    ok;
 determine_async_behavior(_Sink, Threshold, _Window) when not is_integer(Threshold) orelse Threshold < 0 ->
-   error_logger:error_msg("Invalid value for 'async_threshold': ~p~n",
-      [Threshold]),
+   error_logger:error_msg("Invalid value for 'async_threshold': ~p~n", [Threshold]),
    throw({error, bad_config});
 determine_async_behavior(Sink, Threshold, undefined) ->
    start_throttle(Sink, Threshold, erlang:trunc(Threshold * 0.2));
 determine_async_behavior(_Sink, Threshold, Window) when not is_integer(Window) orelse Window > Threshold orelse Window < 0 ->
-   error_logger:error_msg(
-      "Invalid value for 'async_threshold_window': ~p~n", [Window]),
+   error_logger:error_msg("Invalid value for 'async_threshold_window': ~p~n", [Window]),
    throw({error, bad_config});
 determine_async_behavior(Sink, Threshold, Window) ->
    start_throttle(Sink, Threshold, Window).
@@ -56,32 +50,33 @@ determine_async_behavior(Sink, Threshold, Window) ->
 start_handlers(_Sink, undefined) ->
    ok;
 start_handlers(_Sink, Handlers) when not is_list(Handlers) ->
-   error_logger:error_msg(
-      "Invalid value for 'handlers' (must be list): ~p~n", [Handlers]),
+   error_logger:error_msg("Invalid value for 'handlers' (must be list): ~p~n", [Handlers]),
    throw({error, bad_config});
 start_handlers(Sink, Handlers) ->
    %% handlers failing to start are handled in the handler_watcher
-   lager_config:global_set(handlers,
-      lager_config:global_get(handlers, []) ++
-      lists:map(fun({Module, Config}) ->
-         check_handler_config(Module, Config),
-         start_handler(Sink, Module, Config);
-         (_) ->
-            throw({error, bad_config})
-                end,
+   rumConfig:global_set(handlers,
+      rumConfig:global_get(handlers, []) ++
+      lists:map(
+         fun
+            ({Module, Config}) ->
+               check_handler_config(Module, Config),
+               start_handler(Sink, Module, Config);
+            (_) ->
+               throw({error, bad_config})
+         end,
          expand_handlers(Handlers))),
    ok.
 
 start_handler(Sink, Module, Config) ->
-   {ok, Watcher} = supervisor:start_child(lager_handler_watcher_sup,
-      [Sink, Module, Config]),
+   {ok, Watcher} = supervisor:start_child(lager_handler_watcher_sup, [Sink, Module, Config]),
    {Module, Watcher, Sink}.
 
 check_handler_config({lager_file_backend, F}, Config) when is_list(Config); is_tuple(Config) ->
-   Fs = case get(?FILENAMES) of
-           undefined -> ordsets:new();
-           X -> X
-        end,
+   Fs =
+      case get(?FILENAMES) of
+         undefined -> ordsets:new();
+         X -> X
+      end,
    case ordsets:is_element(F, Fs) of
       true ->
          error_logger:error_msg(
@@ -110,8 +105,7 @@ interpret_hwm(HWM) ->
 
 maybe_install_sink_killer(_Sink, undefined, _ReinstallTimer) -> ok;
 maybe_install_sink_killer(Sink, HWM, undefined) -> maybe_install_sink_killer(Sink, HWM, 5000);
-maybe_install_sink_killer(Sink, HWM, ReinstallTimer) when is_integer(HWM) andalso is_integer(ReinstallTimer)
-   andalso HWM >= 0 andalso ReinstallTimer >= 0 ->
+maybe_install_sink_killer(Sink, HWM, ReinstallTimer) when is_integer(HWM) andalso is_integer(ReinstallTimer) andalso HWM >= 0 andalso ReinstallTimer >= 0 ->
    _ = supervisor:start_child(lager_handler_watcher_sup, [Sink, lager_manager_killer,
       [HWM, ReinstallTimer]]);
 maybe_install_sink_killer(_Sink, HWM, ReinstallTimer) ->
@@ -122,20 +116,21 @@ maybe_install_sink_killer(_Sink, HWM, ReinstallTimer) ->
 start_error_logger_handler(false, _HWM, _Whitelist) ->
    [];
 start_error_logger_handler(true, HWM, WhiteList) ->
-   GlStrategy = case application:get_env(lager, error_logger_groupleader_strategy) of
-                   undefined ->
-                      handle;
-                   {ok, GlStrategy0} when
-                      GlStrategy0 =:= handle;
-                      GlStrategy0 =:= ignore;
-                      GlStrategy0 =:= mirror ->
-                      GlStrategy0;
-                   {ok, BadGlStrategy} ->
-                      error_logger:error_msg(
-                         "Invalid value for 'error_logger_groupleader_strategy': ~p~n",
-                         [BadGlStrategy]),
-                      throw({error, bad_config})
-                end,
+   GlStrategy =
+      case application:get_env(lager, error_logger_groupleader_strategy) of
+         undefined ->
+            handle;
+         {ok, GlStrategy0} when
+            GlStrategy0 =:= handle;
+            GlStrategy0 =:= ignore;
+            GlStrategy0 =:= mirror ->
+            GlStrategy0;
+         {ok, BadGlStrategy} ->
+            error_logger:error_msg(
+               "Invalid value for 'error_logger_groupleader_strategy': ~p~n",
+               [BadGlStrategy]),
+            throw({error, bad_config})
+      end,
 
    case whereis(error_logger) of
       undefined ->
@@ -154,13 +149,14 @@ start_error_logger_handler(true, HWM, WhiteList) ->
    end,
 
    %% capture which handlers we removed from error_logger so we can restore them when lager stops
-   OldHandlers = case supervisor:start_child(lager_handler_watcher_sup, [error_logger, error_logger_lager_h, [HWM, GlStrategy]]) of
-                    {ok, _} ->
-                       [begin error_logger:delete_report_handler(X), X end ||
-                          X <- gen_event:which_handlers(error_logger) -- [error_logger_lager_h | WhiteList]];
-                    {error, _} ->
-                       []
-                 end,
+   OldHandlers =
+      case supervisor:start_child(lager_handler_watcher_sup, [error_logger, error_logger_lager_h, [HWM, GlStrategy]]) of
+         {ok, _} ->
+            [begin error_logger:delete_report_handler(X), X end ||
+               X <- gen_event:which_handlers(error_logger) -- [error_logger_lager_h | WhiteList]];
+         {error, _} ->
+            []
+      end,
    OldHandlers.
 
 %% On OTP 21.1 and higher we need to remove the `default' handler.
@@ -177,7 +173,7 @@ maybe_remove_logger_handler() ->
    end.
 
 configure_sink(Sink, SinkDef) ->
-   lager_config:new_sink(Sink),
+   rumConfig:new_sink(Sink),
    ChildId = rumUtil:make_internal_sink_name(Sink),
    _ = supervisor:start_child(eRum_sup,
       {ChildId,
@@ -254,7 +250,7 @@ stop(Handlers) ->
    lists:foreach(fun(Handler) ->
       error_logger:add_report_handler(Handler)
                  end, Handlers),
-   lager_config:cleanup().
+   rumConfig:cleanup().
 
 expand_handlers([]) ->
    [];
@@ -297,110 +293,4 @@ maybe_make_handler_id(Mod, Config) ->
    catch
       error:undef ->
          {Mod, Config}
-   end.
-
--ifdef(TEST).
-application_config_mangling_test_() ->
-   [
-      {"Explode the file backend handlers",
-         ?_assertMatch(
-            [{lager_console_backend, [{level, info}]},
-               {{lager_file_backend, "error.log"}, {"error.log", error, 10485760, "$D0", 5}},
-               {{lager_file_backend, "console.log"}, {"console.log", info, 10485760, "$D0", 5}}
-            ],
-            expand_handlers([{lager_console_backend, [{level, info}]},
-               {lager_file_backend, [
-                  {"error.log", error, 10485760, "$D0", 5},
-                  {"console.log", info, 10485760, "$D0", 5}
-               ]}]
-            ))
-      },
-      {"Explode the short form of backend file handlers",
-         ?_assertMatch(
-            [{lager_console_backend, [{level, info}]},
-               {{lager_file_backend, "error.log"}, {"error.log", error}},
-               {{lager_file_backend, "console.log"}, {"console.log", info}}
-            ],
-            expand_handlers([{lager_console_backend, [{level, info}]},
-               {lager_file_backend, [
-                  {"error.log", error},
-                  {"console.log", info}
-               ]}]
-            ))
-      },
-      {"Explode with formatter info",
-         ?_assertMatch(
-            [{{lager_file_backend, "test.log"}, [{"test.log", debug, 10485760, "$D0", 5}, {lager_default_formatter, ["[", severity, "] ", message, "\n"]}]},
-               {{lager_file_backend, "test2.log"}, [{"test2.log", debug, 10485760, "$D0", 5}, {lager_default_formatter, ["2>[", severity, "] ", message, "\n"]}]}],
-            expand_handlers([{lager_file_backend, [
-               [{"test.log", debug, 10485760, "$D0", 5}, {lager_default_formatter, ["[", severity, "] ", message, "\n"]}],
-               [{"test2.log", debug, 10485760, "$D0", 5}, {lager_default_formatter, ["2>[", severity, "] ", message, "\n"]}]
-            ]
-            }])
-         )
-      },
-      {"Explode short form with short formatter info",
-         ?_assertMatch(
-            [{{lager_file_backend, "test.log"}, [{"test.log", debug}, {lager_default_formatter, ["[", severity, "] ", message, "\n"]}]},
-               {{lager_file_backend, "test2.log"}, [{"test2.log", debug}, {lager_default_formatter}]}],
-            expand_handlers([{lager_file_backend, [
-               [{"test.log", debug}, {lager_default_formatter, ["[", severity, "] ", message, "\n"]}],
-               [{"test2.log", debug}, {lager_default_formatter}]
-            ]
-            }])
-         )
-      },
-      {"New form needs no expansion",
-         ?_assertMatch([
-            {{lager_file_backend, "test.log"}, [{file, "test.log"}]},
-            {{lager_file_backend, "test2.log"}, [{file, "test2.log"}, {level, info}, {sync_on, none}]},
-            {{lager_file_backend, "test3.log"}, [{formatter, lager_default_formatter}, {file, "test3.log"}]}
-         ],
-            expand_handlers([
-               {lager_file_backend, [{file, "test.log"}]},
-               {lager_file_backend, [{file, "test2.log"}, {level, info}, {sync_on, none}]},
-               {lager_file_backend, [{formatter, lager_default_formatter}, {file, "test3.log"}]}
-            ])
-         )
-      }
-   ].
-
-check_handler_config_test_() ->
-   Good = expand_handlers(?DEFAULT_HANDLER_CONF),
-   Bad = expand_handlers([{lager_console_backend, [{level, info}]},
-      {lager_file_backend, [{file, "same_file.log"}]},
-      {lager_file_backend, [{file, "same_file.log"}, {level, info}]}]),
-   AlsoBad = [{lager_logstash_backend,
-      {level, info},
-      {output, {udp, "localhost", 5000}},
-      {format, json},
-      {json_encoder, jiffy}}],
-   BadToo = [{fail, {fail}}],
-   OldSchoolLagerGood = expand_handlers([{lager_console_backend, [{level, info}]},
-      {lager_file_backend, [
-         {"./log/error.log", error, 10485760, "$D0", 5},
-         {"./log/console.log", info, 10485760, "$D0", 5},
-         {"./log/debug.log", debug, 10485760, "$D0", 5}
-      ]}]),
-   NewConfigMissingList = expand_handlers([{foo_backend, {file, "same_file.log"}}]),
-   [
-      {"lager_file_backend_good",
-         ?_assertEqual([ok, ok, ok], [check_handler_config(M, C) || {M, C} <- Good])
-      },
-      {"lager_file_backend_bad",
-         ?_assertThrow({error, bad_config}, [check_handler_config(M, C) || {M, C} <- Bad])
-      },
-      {"Invalid config dies",
-         ?_assertThrow({error, bad_config}, start_handlers(foo, AlsoBad))
-      },
-      {"Invalid config dies",
-         ?_assertThrow({error, {bad_config, _}}, start_handlers(foo, BadToo))
-      },
-      {"Old Lager config works",
-         ?_assertEqual([ok, ok, ok, ok], [check_handler_config(M, C) || {M, C} <- OldSchoolLagerGood])
-      },
-      {"New Config missing its list should fail",
-         ?_assertThrow({error, {bad_config, foo_backend}}, [check_handler_config(M, C) || {M, C} <- NewConfigMissingList])
-      }
-   ].
--endif.
+   end.

src/eRum_sup.erl

@@ -13,23 +13,20 @@ start_link() ->
 
 init([]) ->
    %% set up the config, is safe even during relups
-   lager_config:new(),
+   rumConfig:new(),
    %% TODO:
    %% Always start lager_event as the default and make sure that
    %% other gen_event stuff can start up as needed
    %%
    %% Maybe a new API to handle the sink and its policy?
    Children = [
-      {lager, {gen_event, start_link, [{local, lager_event}]},
-         permanent, 5000, worker, dynamic},
-      {lager_handler_watcher_sup, {lager_handler_watcher_sup, start_link, []},
-         permanent, 5000, supervisor, [lager_handler_watcher_sup]}],
+      {lager, {gen_event, start_link, [{local, lager_event}]}, permanent, 5000, worker, dynamic},
+      {lager_handler_watcher_sup, {lager_handler_watcher_sup, start_link, []}, permanent, 5000, supervisor, [lager_handler_watcher_sup]}
+   ],
 
    CrashLog = decide_crash_log(application:get_env(lager, crash_log, false)),
 
-   {ok, {{one_for_one, 10, 60},
-         Children ++ CrashLog
-   }}.
+   {ok, {{one_for_one, 10, 60}, Children ++ CrashLog}}.
 
 validate_positive({ok, Val}, _Default) when is_integer(Val) andalso Val >= 0 ->
    Val;
@@ -42,8 +39,7 @@ determine_rotation_date({ok, Val3}) ->
    case rumUtil:parse_rotation_date_spec(Val3) of
       {ok, Spec} -> Spec;
       {error, _} ->
-         error_logger:error_msg("Invalid date spec for "
-         "crash log ~p~n", [Val3]),
+         error_logger:error_msg("Invalid date spec for crash log ~p~n", [Val3]),
          undefined
    end;
 determine_rotation_date(_) ->

src/formater/lager_format.erl → src/formatter/rumFormat.erl

@@ -16,7 +16,7 @@
 %% 
 %% %CopyrightEnd%
 %%
--module(lager_format).
+-module(rumFormat).
 
 %% fork of io_lib_format that uses trunc_io to protect against large terms
 

src/formater/lager_default_formatter.erl → src/formatter/rumFormatter.erl

@@ -14,7 +14,7 @@
 %% specific language governing permissions and limitations
 %% under the License.
 
--module(lager_default_formatter).
+-module(rumFormatter).
 
 %%
 %% Include files

src/misc/error_logger_lager_h.erl

@@ -587,7 +587,7 @@ format_args([H | T], FmtAcc, ArgsAcc) ->
    format_args(T, ["~s" | FmtAcc], [Str | ArgsAcc]).
 
 print_silly_list(L) when is_list(L) ->
-   case lager_stdlib:string_p(L) of
+   case rumStdlib:string_p(L) of
       true ->
          lager_trunc_io:format("~s", [L], ?RumDefTruncation);
       _ ->

src/misc/lager_backend_throttle.erl

@@ -48,7 +48,7 @@
 }).
 
 init([{sink, Sink}, Hwm, Window]) ->
-   lager_config:set({Sink, async}, true),
+   rumConfig:set({Sink, async}, true),
    {ok, #state{sink = Sink, hwm = Hwm, window_min = Hwm - Window}}.
 
 
@@ -65,12 +65,12 @@ handle_event({log, _Message}, State) ->
       {true, _, true} ->
          %% need to flip to sync mode
          ?TOGGLE_SYNC(),
-         lager_config:set({State#state.sink, async}, false),
+         rumConfig:set({State#state.sink, async}, false),
          {ok, State#state{async = false}};
       {_, true, false} ->
          %% need to flip to async mode
          ?TOGGLE_ASYNC(),
-         lager_config:set({State#state.sink, async}, true),
+         rumConfig:set({State#state.sink, async}, true),
          {ok, State#state{async = true}};
       _ ->
          %% nothing needs to change

src/misc/lager_config.erl

@@ -1,136 +0,0 @@
-%% Copyright (c) 2011-2012 Basho Technologies, Inc.  All Rights Reserved.
-%%
-%% This file is provided to you under the Apache License,
-%% Version 2.0 (the "License"); you may not use this file
-%% except in compliance with the License.  You may obtain
-%% a copy of the License at
-%%
-%%   http://www.apache.org/licenses/LICENSE-2.0
-%%
-%% Unless required by applicable law or agreed to in writing,
-%% software distributed under the License is distributed on an
-%% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-%% KIND, either express or implied.  See the License for the
-%% specific language governing permissions and limitations
-%% under the License.
-
-%% @doc Helper functions for working with lager's runtime config
-
--module(lager_config).
-
--include("rum.hrl").
-
--export([new/0, new_sink/1, get/1, get/2, set/2,
-   global_get/1, global_get/2, global_set/2, cleanup/0]).
-
--define(TBL, lager_config).
--define(GLOBAL, '_global').
-
-%% For multiple sinks, the key is now the registered event name and the old key
-%% as a tuple.
-%%
-%% {{lager_event, loglevel}, Value} instead of {loglevel, Value}
-
-new() ->
-   init(),
-   new_sink(?RumDefSink),
-   %% Need to be able to find the `lager_handler_watcher' for all handlers
-   insert_new({?GLOBAL, handlers}, []),
-   ok.
-
-new_sink(Sink) ->
-   %% use insert_new here so that if we're in an appup we don't mess anything up
-   %%
-   %% until lager is completely started, allow all messages to go through
-   insert_new({Sink, loglevel}, {element(2, rumUtil:config_to_mask(debug)), []}).
-
-global_get(Key) ->
-   global_get(Key, undefined).
-
-global_get(Key, Default) ->
-   get({?GLOBAL, Key}, Default).
-
-global_set(Key, Value) ->
-   set({?GLOBAL, Key}, Value).
-
-
-get({_Sink, _Key} = FullKey) ->
-   get(FullKey, undefined);
-get(Key) ->
-   get({?RumDefSink, Key}, undefined).
-
-get({Sink, Key}, Default) ->
-   lookup({Sink, Key}, Default);
-get(Key, Default) ->
-   get({?RumDefSink, Key}, Default).
-
-set({Sink, Key}, Value) ->
-   insert({Sink, Key}, Value);
-set(Key, Value) ->
-   set({?RumDefSink, Key}, Value).
-
-%% check if we can use persistent_term for config
-%% persistent term was added in OTP 21.2 but we can't
-%% check minor versions with macros so we're stuck waiting
-%% for OTP 22
--ifdef(HAVE_PERSISTENT_TERM).
-init() ->
-   ok.
-
-insert(Key, Value) ->
-   persistent_term:put({?TBL, Key}, Value).
-
-insert_new(Key, Value) ->
-   try persistent_term:get({?TBL, Key}) of
-      _Value ->
-         false
-   catch error:badarg ->
-      insert(Key, Value),
-      true
-   end.
-
-lookup(Key, Default) ->
-   try persistent_term:get({?TBL, Key}) of
-      Value -> Value
-   catch
-      error:badarg ->
-         Default
-   end.
-
-cleanup() ->
-   [persistent_term:erase(K) || {{?TBL, _} = K, _} <- persistent_term:get()].
-
--else.
-
-init() ->
-   %% set up the ETS configuration table
-   _ = try ets:new(?TBL, [named_table, public, set, {keypos, 1}, {read_concurrency, true}]) of
-          _Result ->
-             ok
-       catch
-          error:badarg ->
-             ?INT_LOG(warning, "Table ~p already exists", [?TBL])
-       end.
-
-insert(Key, Value) ->
-   ets:insert(?TBL, {Key, Value}).
-
-insert_new(Key, Value) ->
-   ets:insert_new(?TBL, {Key, Value}).
-
-lookup(Key, Default) ->
-   try
-      case ets:lookup(?TBL, Key) of
-         [] ->
-            Default;
-         [{Key, Res}] ->
-            Res
-      end
-   catch
-      _:_ ->
-         Default
-   end.
-
-cleanup() -> ok.
--endif.
-

src/misc/lager_console_backend.erl

@@ -287,7 +287,7 @@ console_log_test_() ->
                register(user, Pid),
                erlang:group_leader(Pid, whereis(lager_event)),
                gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
-               lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:log(info, self(), "Test message"),
                receive
                   {io_request, From, ReplyAs, {put_chars, unicode, Msg}} ->
@@ -307,7 +307,7 @@ console_log_test_() ->
                register(user, Pid),
                erlang:group_leader(Pid, whereis(lager_event)),
                gen_event:add_handler(lager_event, lager_console_backend, [info, true]),
-               lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:info("Test message"),
                PidStr = pid_to_list(self()),
                receive
@@ -329,7 +329,7 @@ console_log_test_() ->
                gen_event:add_handler(lager_event, lager_console_backend,
                   [{level, info}, {formatter, lager_default_formatter}, {formatter_config, [date, "#", time, "#", severity, "#", node, "#", pid, "#",
                      module, "#", function, "#", file, "#", line, "#", message, "\r\n"]}]),
-               lager_config:set({lager_event, loglevel}, {?INFO, []}),
+               rumConfig:set({lager_event, loglevel}, {?INFO, []}),
                eRum:info("Test message"),
                PidStr = pid_to_list(self()),
                NodeStr = atom_to_list(node()),
@@ -352,7 +352,7 @@ console_log_test_() ->
                register(user, Pid),
                gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
                erlang:group_leader(Pid, whereis(lager_event)),
-               lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:debug("Test message"),
                receive
                   {io_request, From, ReplyAs, {put_chars, unicode, _Msg}} ->
@@ -381,7 +381,7 @@ console_log_test_() ->
                unregister(user),
                register(user, Pid),
                gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
-               lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                erlang:group_leader(Pid, whereis(lager_event)),
                eRum:debug("Test message"),
                receive
@@ -420,7 +420,7 @@ console_log_test_() ->
                unregister(user),
                register(user, Pid),
                gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
-               lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:set_loglevel(lager_console_backend, '!=info'),
                erlang:group_leader(Pid, whereis(lager_event)),
                eRum:debug("Test message"),
@@ -451,7 +451,7 @@ console_log_test_() ->
                unregister(user),
                register(user, Pid),
                gen_event:add_handler(lager_event, lager_console_backend, [{level, info}]),
-               lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:set_loglevel(lager_console_backend, '=debug'),
                erlang:group_leader(Pid, whereis(lager_event)),
                eRum:debug("Test message"),
@@ -480,7 +480,7 @@ console_log_test_() ->
             fun() ->
                Pid = spawn(F(self())),
                gen_event:add_handler(lager_event, lager_console_backend, [{level, info}, {group_leader, Pid}]),
-               lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
+               rumConfig:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                eRum:info("Test message"),
                ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(lager_event), group_leader)),
                receive
@@ -513,11 +513,11 @@ console_log_test_() ->
             fun() ->
                Pid = spawn(F(self())),
                ID = {?MODULE, trace_test},
-               Handlers = lager_config:global_get(handlers, []),
+               Handlers = rumConfig:global_get(handlers, []),
                HandlerInfo = lager_app:start_handler(lager_event, ID,
                   [{level, none}, {group_leader, Pid},
                      {id, ID}]),
-               lager_config:global_set(handlers, [HandlerInfo | Handlers]),
+               rumConfig:global_set(handlers, [HandlerInfo | Handlers]),
                eRum:info("Test message"),
                ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(lager_event), group_leader)),
                receive
@@ -539,7 +539,7 @@ console_log_test_() ->
                   500 ->
                      ?assert(false)
                end,
-               ?assertNotEqual({0, []}, lager_config:get({lager_event, loglevel})),
+               ?assertNotEqual({0, []}, rumConfig:get({lager_event, loglevel})),
                %% killing the pid should prevent any new log messages (to prove we haven't accidentally redirected
                %% the group leader some other way
                exit(Pid, kill),
@@ -547,7 +547,7 @@ console_log_test_() ->
                %% additionally, check the lager backend has been removed (because the group leader process died)
                ?assertNot(lists:member(lager_console_backend, gen_event:which_handlers(lager_event))),
                %% finally, check the trace has been removed
-               ?assertEqual({0, []}, lager_config:get({lager_event, loglevel})),
+               ?assertEqual({0, []}, rumConfig:get({lager_event, loglevel})),
                eRum:error("Test message"),
                receive
                   {io_request, From3, ReplyAs3, {put_chars, unicode, _Msg3}} ->

src/misc/lager_crash_log.erl

@@ -146,7 +146,7 @@ other_node_suffix(_) ->
    "".
 
 perhaps_a_sasl_report(error_report, {Pid, Type, Report}, FmtMaxBytes) ->
-   case lager_stdlib:is_my_error_report(Type) of
+   case rumStdlib:is_my_error_report(Type) of
       true ->
          {sasl_type_to_report_head(Type), Pid,
             sasl_limited_str(Type, Report, FmtMaxBytes), true};
@@ -172,10 +172,10 @@ sasl_type_to_report_head(progress) ->
    "PROGRESS REPORT".
 
 sasl_limited_str(supervisor_report, Report, FmtMaxBytes) ->
-   Name = lager_stdlib:sup_get(supervisor, Report),
-   Context = lager_stdlib:sup_get(errorContext, Report),
-   Reason = lager_stdlib:sup_get(reason, Report),
-   Offender = lager_stdlib:sup_get(offender, Report),
+   Name = rumStdlib:sup_get(supervisor, Report),
+   Context = rumStdlib:sup_get(errorContext, Report),
+   Reason = rumStdlib:sup_get(reason, Report),
+   Offender = rumStdlib:sup_get(offender, Report),
    FmtString = "     Supervisor: ~p~n     Context:    ~p~n     Reason:     "
    "~s~n     Offender:   ~s~n~n",
    {ReasonStr, _} = lager_trunc_io:print(Reason, FmtMaxBytes),
@@ -187,7 +187,7 @@ sasl_limited_str(progress, Report, FmtMaxBytes) ->
        io_lib:format("    ~16w: ~s~n", [Tag, Str])
     end || {Tag, Data} <- Report];
 sasl_limited_str(crash_report, Report, FmtMaxBytes) ->
-   lager_stdlib:proc_lib_format(Report, FmtMaxBytes).
+   rumStdlib:proc_lib_format(Report, FmtMaxBytes).
 
 do_log({log, Event}, #state{name = Name, fd = FD, inode = Inode, ctime = Ctime, flap = Flap,
    fmtmaxbytes = FmtMaxBytes, size = RotSize, count = Count, rotator = Rotator} = State) ->
@@ -211,7 +211,7 @@ do_log({log, Event}, #state{name = Name, fd = FD, inode = Inode, ctime = Ctime,
                handle_cast({log, Event}, State);
             {ok, {NewFD, NewInode, NewCtime, _Size}} ->
                {Date, TS} = rumUtil:format_time(
-                  lager_stdlib:maybe_utc(erlang:localtime())),
+                  rumStdlib:maybe_utc(erlang:localtime())),
                Time = [Date, " ", TS, " =", ReportStr, "====\n"],
                NodeSuffix = other_node_suffix(Pid),
                Msg = io_lib:format("~s~s~s", [Time, MsgStr, NodeSuffix]),

src/misc/lager_file_backend.erl

@@ -909,8 +909,8 @@ filesystem_test_() ->
             gen_event:add_handler(lager_event, lager_file_backend, {TestLog, critical}),
             eRum:error("Test message"),
             ?assertEqual({ok, <<>>}, file:read_file(TestLog)),
-            {Level, _} = lager_config:get({lager_event, loglevel}),
-            lager_config:set({lager_event, loglevel}, {Level,
+            {Level, _} = rumConfig:get({lager_event, loglevel}),
+            rumConfig:set({lager_event, loglevel}, {Level,
                [{[{module, ?MODULE}], ?DEBUG, {lager_file_backend, TestLog}}]}),
             eRum:error("Test message"),
             timer:sleep(1000),
@@ -937,8 +937,8 @@ filesystem_test_() ->
                   ?assertMatch([_, _, "[critical]", _, "Test message\n"],
                      re:split(Bin1, " ", [{return, list}, {parts, 5}])),
                   ?assertEqual(ok, file:delete(TestLog)),
-                  {Level, _} = lager_config:get({lager_event, loglevel}),
-                  lager_config:set({lager_event, loglevel},
+                  {Level, _} = rumConfig:get({lager_event, loglevel}),
+                  rumConfig:set({lager_event, loglevel},
                      {Level, [{[{module, ?MODULE}], ?DEBUG, {lager_file_backend, TestLog}}]}),
                   eRum:critical("Test message"),
                   {ok, Bin2} = file:read_file(TestLog),

src/misc/lager_trunc_io.erl

@@ -60,7 +60,7 @@ format(Fmt, Args, Max) ->
    format(Fmt, Args, Max, []).
 
 format(Fmt, Args, Max, Options) ->
-   try lager_format:format(Fmt, Args, Max, Options)
+   try rumFormat:format(Fmt, Args, Max, Options)
    catch
       _What:_Why ->
          erlang:error(badarg, [Fmt, Args])

src/misc/rumConfig.erl

@@ -0,0 +1,84 @@
+-module(rumConfig).
+
+-include("rum.hrl").
+
+-export([
+   new/0
+   , new_sink/1
+   , get/1
+   , get/2
+   , set/2
+   , global_get/1
+   , global_get/2
+   , global_set/2
+   , cleanup/0
+]).
+
+-define(TBL, lager_config).
+-define(GLOBAL, '_global').
+
+%% For multiple sinks, the key is now the registered event name and the old key as a tuple.
+%% {{lager_event, loglevel}, Value} instead of {loglevel, Value}
+
+new() ->
+   init(),
+   new_sink(?RumDefSink),
+   %% Need to be able to find the `lager_handler_watcher' for all handlers
+   insert_new({?GLOBAL, handlers}, []),
+   ok.
+
+new_sink(Sink) ->
+   %% use insert_new here so that if we're in an appup we don't mess anything up until lager is completely started, allow all messages to go through
+   insert_new({Sink, loglevel}, {element(2, rumUtil:config_to_mask(debug)), []}).
+
+global_get(Key) ->
+   global_get(Key, undefined).
+
+global_get(Key, Default) ->
+   get({?GLOBAL, Key}, Default).
+
+global_set(Key, Value) ->
+   set({?GLOBAL, Key}, Value).
+
+
+get({_Sink, _Key} = FullKey) ->
+   get(FullKey, undefined);
+get(Key) ->
+   get({?RumDefSink, Key}, undefined).
+
+get({Sink, Key}, Default) ->
+   lookup({Sink, Key}, Default);
+get(Key, Default) ->
+   get({?RumDefSink, Key}, Default).
+
+set({Sink, Key}, Value) ->
+   insert({Sink, Key}, Value);
+set(Key, Value) ->
+   set({?RumDefSink, Key}, Value).
+
+init() ->
+   ok.
+
+insert(Key, Value) ->
+   persistent_term:put({?TBL, Key}, Value).
+
+insert_new(Key, Value) ->
+   try persistent_term:get({?TBL, Key}) of
+      _Value ->
+         false
+   catch error:badarg ->
+      insert(Key, Value),
+      true
+   end.
+
+lookup(Key, Default) ->
+   try persistent_term:get({?TBL, Key}) of
+      Value -> Value
+   catch
+      error:badarg ->
+         Default
+   end.
+
+cleanup() ->
+   [persistent_term:erase(K) || {{?TBL, _} = K, _} <- persistent_term:get()].
+

src/misc/lager_stdlib.erl → src/misc/rumStdlib.erl

@@ -24,7 +24,7 @@
 %% distribution's license, the Erlang Public License.  See
 %% http://www.erlang.org/ for full details.
 
--module(lager_stdlib).
+-module(rumStdlib).
 
 -export([string_p/1]).
 -export([write_time/2, maybe_utc/1]).

src/misc/rumUtil.erl

@@ -155,7 +155,7 @@ localtime_ms(Now) ->
 
 
 maybe_utc({Date, {H, M, S, Ms}}) ->
-   case lager_stdlib:maybe_utc({Date, {H, M, S}}) of
+   case rumStdlib:maybe_utc({Date, {H, M, S}}) of
       {utc, {Date1, {H1, M1, S1}}} ->
          {utc, {Date1, {H1, M1, S1, Ms}}};
       {Date1, {H1, M1, S1}} ->

src/rotator/lager_rotator_behaviour.erl → src/rotator/rumRotatorExm.erl

@@ -1,4 +1,4 @@
--module(lager_rotator_behaviour).
+-module(rumRotatorExm).
 
 %% Create a log file
 -callback(create_logfile(Name :: list(), Buffer :: {integer(), integer()} | any()) ->

src/rotator/lager_rotator_default.erl → src/rotator/rumRotatorIns.erl

@@ -1,8 +1,8 @@
--module(lager_rotator_default).
+-module(rumRotatorIns).
 
 -include_lib("kernel/include/file.hrl").
 
--behaviour(lager_rotator_behaviour).
+-behaviour(rumRotatorExm).
 
 -export([
    create_logfile/2, open_logfile/2, ensure_logfile/5, rotate_logfile/2

src/transform/lager_transform.erl → src/transform/rumTransform.erl

@@ -1,27 +1,4 @@
-%% Copyright (c) 2011-2012 Basho Technologies, Inc.  All Rights Reserved.
-%%
-%% This file is provided to you under the Apache License,
-%% Version 2.0 (the "License"); you may not use this file
-%% except in compliance with the License.  You may obtain
-%% a copy of the License at
-%%
-%%   http://www.apache.org/licenses/LICENSE-2.0
-%%
-%% Unless required by applicable law or agreed to in writing,
-%% software distributed under the License is distributed on an
-%% "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-%% KIND, either express or implied.  See the License for the
-%% specific language governing permissions and limitations
-%% under the License.
-
-%% @doc The parse transform used for lager messages.
-%% This parse transform rewrites functions calls to lager:Severity/1,2 into
-%% a more complicated function that captures module, function, line, pid and
-%% time as well. The entire function call is then wrapped in a case that
-%% checks the lager_config 'loglevel' value, so the code isn't executed if
-%% nothing wishes to consume the message.
-
--module(lager_transform).
+-module(rumTransform).
 
 -include("rum.hrl").
 

test/lager_manager_killer_test.erl

@@ -23,7 +23,7 @@ overload_test_() ->
          application:set_env(lager, killer_hwm, KillerHWM),
          application:set_env(lager, killer_reinstall_after, KillerReinstallAfter),
          ensure_started(lager),
-         lager_config:set(async, true),
+         rumConfig:set(async, true),
          Manager = whereis(lager_event),
          erlang:trace(all, true, [procs]),
          [eRum:info("~p'th message", [N]) || N <- lists:seq(1, KillerHWM + 2)],
@@ -63,7 +63,7 @@ overload_alternate_sink_test_() ->
          ]}]),
          application:set_env(lager, error_logger_redirect, true),
          ensure_started(lager),
-         lager_config:set({?TEST_SINK_EVENT, async}, true),
+         rumConfig:set({?TEST_SINK_EVENT, async}, true),
          Manager = whereis(?TEST_SINK_EVENT),
          erlang:trace(all, true, [procs]),
          [?TEST_SINK_NAME:info("~p'th message", [N]) || N <- lists:seq(1, KillerHWM + 2)],

test/lager_metadata_whitelist_test.erl

@@ -37,7 +37,7 @@ basic_test_() ->
          ok = application:set_env(lager, metadata_whitelist, Whitelist),
          Msg = lager_msg:new("Message", Now, error, [], []),
          Expected = iolist_to_binary([Date, " ", Time, " [error]  Message\n"]),
-         Got = iolist_to_binary(lager_default_formatter:format(Msg, [])),
+         Got = iolist_to_binary(rumFormatter:format(Msg, [])),
          ?assertEqual(Expected, Got)
                 end},
          {"Meta1", fun() ->
@@ -45,7 +45,7 @@ basic_test_() ->
             ok = application:set_env(lager, metadata_whitelist, Whitelist),
             Msg = lager_msg:new("Message", Now, error, [{meta1, "value1"}], []),
             Expected = iolist_to_binary([Date, " ", Time, " [error]  meta1=value1 Message\n"]),
-            Got = iolist_to_binary(lager_default_formatter:format(Msg, [])),
+            Got = iolist_to_binary(rumFormatter:format(Msg, [])),
             ?assertEqual(Expected, Got)
                    end},
          {"Meta2", fun() ->
@@ -53,7 +53,7 @@ basic_test_() ->
             ok = application:set_env(lager, metadata_whitelist, Whitelist),
             Msg = lager_msg:new("Message", Now, error, [{meta1, "value1"}, {meta2, 2}], []),
             Expected = iolist_to_binary([Date, " ", Time, " [error]  meta1=value1 meta2=2 Message\n"]),
-            Got = iolist_to_binary(lager_default_formatter:format(Msg, [])),
+            Got = iolist_to_binary(rumFormatter:format(Msg, [])),
             ?assertEqual(Expected, Got)
                    end},
          {"Meta3", fun() ->
@@ -61,7 +61,7 @@ basic_test_() ->
             ok = application:set_env(lager, metadata_whitelist, Whitelist),
             Msg = lager_msg:new("Message", Now, error, [{meta1, "value1"}, {meta3, 3}], []),
             Expected = iolist_to_binary([Date, " ", Time, " [error]  meta1=value1 Message\n"]),
-            Got = iolist_to_binary(lager_default_formatter:format(Msg, [])),
+            Got = iolist_to_binary(rumFormatter:format(Msg, [])),
             ?assertEqual(Expected, Got)
                    end}
       ]

test/lager_test_backend.erl

@@ -417,12 +417,12 @@ lager_test_() ->
                eRum:debug("this message will be ignored"),
                ?assertEqual(0, count()),
                ?assertEqual(0, count_ignored()),
-               lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(debug)), []}),
+               rumConfig:set(loglevel, {element(2, rumUtil:config_to_mask(debug)), []}),
                eRum:debug("this message should be ignored"),
                ?assertEqual(0, count()),
                ?assertEqual(1, count_ignored()),
                eRum:set_loglevel(?MODULE, debug),
-               ?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)),
+               ?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get(loglevel)),
                eRum:debug("this message should be logged"),
                ?assertEqual(1, count()),
                ?assertEqual(1, count_ignored()),
@@ -432,11 +432,11 @@ lager_test_() ->
          },
          {"tracing works",
             fun() ->
-               lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
+               rumConfig:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
                ok = eRum:info("hello world"),
                ?assertEqual(0, count()),
                eRum:trace(?MODULE, [{module, ?MODULE}], debug),
-               ?assertMatch({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, _}, lager_config:get(loglevel)),
+               ?assertMatch({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, _}, rumConfig:get(loglevel)),
                %% elegible for tracing
                ok = eRum:info("hello world"),
                %% NOT elegible for tracing
@@ -448,8 +448,8 @@ lager_test_() ->
          {"tracing works with custom attributes",
             fun() ->
                eRum:set_loglevel(?MODULE, error),
-               ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)),
-               lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
+               ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get(loglevel)),
+               rumConfig:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
                eRum:info([{requestid, 6}], "hello world"),
                ?assertEqual(0, count()),
                eRum:trace(?MODULE, [{requestid, 6}, {foo, bar}], debug),
@@ -467,8 +467,8 @@ lager_test_() ->
          {"tracing works with custom attributes and event stream processing",
             fun() ->
                eRum:set_loglevel(?MODULE, error),
-               ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)),
-               lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
+               ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get(loglevel)),
+               rumConfig:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
                eRum:info([{requestid, 6}], "hello world"),
                ?assertEqual(0, count()),
                eRum:trace(?MODULE, [{requestid, '>', 5}, {requestid, '<', 7}, {foo, bar}], debug),
@@ -535,8 +535,8 @@ lager_test_() ->
          {"tracing custom attributes works with event stream processing statistics and reductions",
             fun() ->
                eRum:set_loglevel(?MODULE, error),
-               ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)),
-               lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
+               ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get(loglevel)),
+               rumConfig:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
                eRum:info([{requestid, 6}], "hello world"),
                ?assertEqual(0, count()),
                eRum:trace(?MODULE, [{beta, '*'}]),
@@ -590,7 +590,7 @@ lager_test_() ->
          {"tracing honors loglevel",
             fun() ->
                eRum:set_loglevel(?MODULE, error),
-               ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)),
+               ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get(loglevel)),
                {ok, T} = eRum:trace(?MODULE, [{module, ?MODULE}], notice),
                ok = eRum:info("hello world"),
                ?assertEqual(0, count()),
@@ -607,29 +607,29 @@ lager_test_() ->
                fun() ->
                   Sink = ?RumDefSink,
                   StartHandlers = gen_event:which_handlers(Sink),
-                  {_, T0} = lager_config:get({Sink, loglevel}),
-                  StartGlobal = lager_config:global_get(handlers),
+                  {_, T0} = rumConfig:get({Sink, loglevel}),
+                  StartGlobal = rumConfig:global_get(handlers),
                   ?assertEqual([], T0),
                   {ok, TestTrace1} = eRum:trace_file("/tmp/test", [{a, b}]),
                   MidHandlers = gen_event:which_handlers(Sink),
                   {ok, TestTrace2} = eRum:trace_file("/tmp/test", [{c, d}]),
                   MidHandlers = gen_event:which_handlers(Sink),
                   ?assertEqual(length(StartHandlers) + 1, length(MidHandlers)),
-                  MidGlobal = lager_config:global_get(handlers),
+                  MidGlobal = rumConfig:global_get(handlers),
                   ?assertEqual(length(StartGlobal) + 1, length(MidGlobal)),
-                  {_, T1} = lager_config:get({Sink, loglevel}),
+                  {_, T1} = rumConfig:get({Sink, loglevel}),
                   ?assertEqual(2, length(T1)),
                   ok = eRum:stop_trace(TestTrace1),
-                  {_, T2} = lager_config:get({Sink, loglevel}),
+                  {_, T2} = rumConfig:get({Sink, loglevel}),
                   ?assertEqual(1, length(T2)),
                   ?assertEqual(length(StartHandlers) + 1, length(
                      gen_event:which_handlers(Sink))),
 
-                  ?assertEqual(length(StartGlobal) + 1, length(lager_config:global_get(handlers))),
+                  ?assertEqual(length(StartGlobal) + 1, length(rumConfig:global_get(handlers))),
                   ok = eRum:stop_trace(TestTrace2),
                   EndHandlers = gen_event:which_handlers(Sink),
-                  EndGlobal = lager_config:global_get(handlers),
-                  {_, T3} = lager_config:get({Sink, loglevel}),
+                  EndGlobal = rumConfig:global_get(handlers),
+                  {_, T3} = rumConfig:get({Sink, loglevel}),
                   ?assertEqual([], T3),
                   ?assertEqual(StartHandlers, EndHandlers),
                   ?assertEqual(StartGlobal, EndGlobal),
@@ -687,9 +687,9 @@ lager_test_() ->
          },
          {"installing a new handler adjusts the global loglevel if necessary",
             fun() ->
-               ?assertEqual({?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)),
+               ?assertEqual({?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get(loglevel)),
                supervisor:start_child(lager_handler_watcher_sup, [lager_event, {?MODULE, foo}, debug]),
-               ?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)),
+               ?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get(loglevel)),
                ok
             end
          },
@@ -815,29 +815,29 @@ extra_sinks_test_() ->
             fun() ->
                Sink = ?TEST_SINK_EVENT,
                StartHandlers = gen_event:which_handlers(Sink),
-               {_, T0} = lager_config:get({Sink, loglevel}),
-               StartGlobal = lager_config:global_get(handlers),
+               {_, T0} = rumConfig:get({Sink, loglevel}),
+               StartGlobal = rumConfig:global_get(handlers),
                ?assertEqual([], T0),
                {ok, TestTrace1} = eRum:trace_file("/tmp/test", [{sink, Sink}, {a, b}]),
                MidHandlers = gen_event:which_handlers(Sink),
                {ok, TestTrace2} = eRum:trace_file("/tmp/test", [{sink, Sink}, {c, d}]),
                MidHandlers = gen_event:which_handlers(Sink),
                ?assertEqual(length(StartHandlers) + 1, length(MidHandlers)),
-               MidGlobal = lager_config:global_get(handlers),
+               MidGlobal = rumConfig:global_get(handlers),
                ?assertEqual(length(StartGlobal) + 1, length(MidGlobal)),
-               {_, T1} = lager_config:get({Sink, loglevel}),
+               {_, T1} = rumConfig:get({Sink, loglevel}),
                ?assertEqual(2, length(T1)),
                ok = eRum:stop_trace(TestTrace1),
-               {_, T2} = lager_config:get({Sink, loglevel}),
+               {_, T2} = rumConfig:get({Sink, loglevel}),
                ?assertEqual(1, length(T2)),
                ?assertEqual(length(StartHandlers) + 1, length(
                   gen_event:which_handlers(Sink))),
 
-               ?assertEqual(length(StartGlobal) + 1, length(lager_config:global_get(handlers))),
+               ?assertEqual(length(StartGlobal) + 1, length(rumConfig:global_get(handlers))),
                ok = eRum:stop_trace(TestTrace2),
                EndHandlers = gen_event:which_handlers(Sink),
-               EndGlobal = lager_config:global_get(handlers),
-               {_, T3} = lager_config:get({Sink, loglevel}),
+               EndGlobal = rumConfig:global_get(handlers),
+               {_, T3} = rumConfig:get({Sink, loglevel}),
                ?assertEqual([], T3),
                ?assertEqual(StartHandlers, EndHandlers),
                ?assertEqual(StartGlobal, EndGlobal),
@@ -850,12 +850,12 @@ extra_sinks_test_() ->
                ?TEST_SINK_NAME:debug("this message will be ignored"),
                ?assertEqual(0, count(?TEST_SINK_EVENT)),
                ?assertEqual(0, count_ignored(?TEST_SINK_EVENT)),
-               lager_config:set({?TEST_SINK_EVENT, loglevel}, {element(2, rumUtil:config_to_mask(debug)), []}),
+               rumConfig:set({?TEST_SINK_EVENT, loglevel}, {element(2, rumUtil:config_to_mask(debug)), []}),
                ?TEST_SINK_NAME:debug("this message should be ignored"),
                ?assertEqual(0, count(?TEST_SINK_EVENT)),
                ?assertEqual(1, count_ignored(?TEST_SINK_EVENT)),
                eRum:set_loglevel(?TEST_SINK_EVENT, ?MODULE, undefined, debug),
-               ?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({?TEST_SINK_EVENT, loglevel})),
+               ?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get({?TEST_SINK_EVENT, loglevel})),
                ?TEST_SINK_NAME:debug("this message should be logged"),
                ?assertEqual(1, count(?TEST_SINK_EVENT)),
                ?assertEqual(1, count_ignored(?TEST_SINK_EVENT)),
@@ -1455,7 +1455,7 @@ error_logger_redirect_test_() ->
       {"supervisor progress report",
          fun(Sink) ->
             eRum:set_loglevel(Sink, ?MODULE, undefined, debug),
-            ?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})),
+            ?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get({Sink, loglevel})),
             sync_error_logger:info_report(progress, [{supervisor, {local, foo}}, {started, [{mfargs, {foo, bar, 1}}, {pid, baz}]}]),
             _ = gen_event:which_handlers(error_logger),
             {Level, _, Msg, Metadata} = pop(Sink),
@@ -1467,7 +1467,7 @@ error_logger_redirect_test_() ->
       {"supervisor progress report with pid",
          fun(Sink) ->
             eRum:set_loglevel(Sink, ?MODULE, undefined, debug),
-            ?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})),
+            ?assertEqual({?DEBUG bor ?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get({Sink, loglevel})),
             sync_error_logger:info_report(progress, [{supervisor, somepid}, {started, [{mfargs, {foo, bar, 1}}, {pid, baz}]}]),
             _ = gen_event:which_handlers(error_logger),
             {Level, _, Msg, Metadata} = pop(Sink),
@@ -1694,20 +1694,20 @@ error_logger_redirect_test_() ->
       {"messages should not be generated if they don't satisfy the threshold",
          fun(Sink) ->
             eRum:set_loglevel(Sink, ?MODULE, undefined, error),
-            ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})),
+            ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get({Sink, loglevel})),
             sync_error_logger:info_report([hello, world]),
             _ = gen_event:which_handlers(error_logger),
             ?assertEqual(0, count(Sink)),
             ?assertEqual(0, count_ignored(Sink)),
             eRum:set_loglevel(Sink, ?MODULE, undefined, info),
-            ?assertEqual({?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})),
+            ?assertEqual({?INFO bor ?NOTICE bor ?WARNING bor ?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get({Sink, loglevel})),
             sync_error_logger:info_report([hello, world]),
             _ = gen_event:which_handlers(error_logger),
             ?assertEqual(1, count(Sink)),
             ?assertEqual(0, count_ignored(Sink)),
             eRum:set_loglevel(Sink, ?MODULE, undefined, error),
-            ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get({Sink, loglevel})),
-            lager_config:set({Sink, loglevel}, {element(2, rumUtil:config_to_mask(debug)), []}),
+            ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, rumConfig:get({Sink, loglevel})),
+            rumConfig:set({Sink, loglevel}, {element(2, rumUtil:config_to_mask(debug)), []}),
             sync_error_logger:info_report([hello, world]),
             _ = gen_event:which_handlers(error_logger),
             ?assertEqual(1, count(Sink)),
@@ -1779,7 +1779,7 @@ async_threshold_test_() ->
             Sleep = get_long_sleep_value(),
 
             %% we start out async
-            ?assertEqual(true, lager_config:get(async)),
+            ?assertEqual(true, rumConfig:get(async)),
             ?assertEqual([{sync_toggled, 0}],
                ets:lookup(async_threshold_test, sync_toggled)),
 
@@ -1817,7 +1817,7 @@ async_threshold_test_() ->
             timer:sleep(Sleep),
 
             %% async is true again now that the mailbox has drained
-            ?assertEqual(true, lager_config:get(async)),
+            ?assertEqual(true, rumConfig:get(async)),
             ok
                        end}}
    ]}.