ft:修改

include/lager.hrl

@@ -1,178 +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.
-
-
--define(DEFAULT_TRUNCATION, 4096).
--define(DEFAULT_TRACER, lager_default_tracer).
--define(DEFAULT_SINK, lager_event).
--define(ERROR_LOGGER_SINK, error_logger_lager_event).
-
--define(METADATA(Extras), [{severity, info},
-                           {pid, self()},
-                           {node, node()},
-                           {module, ?MODULE},
-                           {function, ?FUNCTION_NAME},
-                           {function_arity, ?FUNCTION_ARITY},
-                           {file, ?FILE},
-                           {line, ?LINE} | Extras]).
-
--define(lager_log(Severity, Format, Args, Safety),
-        ?lager_log(?DEFAULT_SINK, Severity, ?METADATA(lager:md()), Format, Args,
-                   ?DEFAULT_TRUNCATION, Safety)).
--define(lager_log(Severity, Metadata, Format, Args, Safety),
-        ?lager_log(?DEFAULT_SINK, Severity, ?METADATA(Metadata++lager:md()), Format, Args,
-                   ?DEFAULT_TRUNCATION, Safety)).
-
--define(lager_log(Sink, Severity, Metadata, Format, Args, Size, Safety),
-        _ = lager:dispatch_log(Sink, Severity, Metadata, Format, Args, Size, Safety)).
-
--define(lager_debug(Format, Args), ?lager_log(debug, Format, Args, safe)).
--define(lager_debug(Metadata, Format, Args), ?lager_log(debug, Metadata, Format, Args, safe)).
-
--define(lager_info(Format, Args), ?lager_log(info, Format, Args, safe)).
--define(lager_info(Metadata, Format, Args), ?lager_log(info, Metadata, Format, Args, safe)).
-
--define(lager_notice(Format, Args), ?lager_log(notice, Format, Args, safe)).
--define(lager_notice(Metadata, Format, Args), ?lager_log(notice, Metadata, Format, Args, safe)).
-
--define(lager_warning(Format, Args), ?lager_log(warning, Format, Args, safe)).
--define(lager_warning(Metadata, Format, Args), ?lager_log(warning, Metadata, Format, Args, safe)).
-
--define(lager_error(Format, Args), ?lager_log(error, Format, Args, safe)).
--define(lager_error(Metadata, Format, Args), ?lager_log(error, Metadata, Format, Args, safe)).
-
--define(lager_critical(Format, Args), ?lager_log(critical, Format, Args, safe)).
--define(lager_critical(Metadata, Format, Args), ?lager_log(critical, Metadata, Format, Args, safe)).
-
--define(lager_alert(Format, Args), ?lager_log(alert, Format, Args, safe)).
--define(lager_alert(Metadata, Format, Args), ?lager_log(alert, Metadata, Format, Args, safe)).
-
--define(lager_emergency(Format, Args), ?lager_log(emergency, Format, Args, safe)).
--define(lager_emergency(Metadata, Format, Args), ?lager_log(emergency, Metadata, Format, Args, safe)).
-
--define(lager_none(Format, Args), ?lager_log(none, Format, Args, safe)).
--define(lager_none(Metadata, Format, Args), ?lager_log(none, Metadata, Format, Args, safe)).
-
--define(LEVELS,
-    [debug, info, notice, warning, error, critical, alert, emergency, none]).
-
-%% Use of these "functions" means that the argument list will not be
-%% truncated for safety
--define(LEVELS_UNSAFE,
-    [{debug_unsafe, debug}, {info_unsafe, info}, {notice_unsafe, notice}, {warning_unsafe, warning}, {error_unsafe, error}, {critical_unsafe, critical}, {alert_unsafe, alert}, {emergency_unsafe, emergency}]).
-
--define(DEBUG, 128).
--define(INFO, 64).
--define(NOTICE, 32).
--define(WARNING, 16).
--define(ERROR, 8).
--define(CRITICAL, 4).
--define(ALERT, 2).
--define(EMERGENCY, 1).
--define(LOG_NONE, 0).
-
--define(LEVEL2NUM(Level),
-    case Level of
-        debug -> ?DEBUG;
-        info -> ?INFO;
-        notice -> ?NOTICE;
-        warning -> ?WARNING;
-        error -> ?ERROR;
-        critical -> ?CRITICAL;
-        alert -> ?ALERT;
-        emergency -> ?EMERGENCY
-    end).
-
--define(NUM2LEVEL(Num),
-    case Num of
-        ?DEBUG -> debug;
-        ?INFO -> info;
-        ?NOTICE -> notice;
-        ?WARNING -> warning;
-        ?ERROR -> error;
-        ?CRITICAL -> critical;
-        ?ALERT -> alert;
-        ?EMERGENCY -> emergency
-    end).
-
--define(SHOULD_LOG(Sink, Level),
-    (lager_util:level_to_num(Level) band element(1, lager_config:get({Sink, loglevel}, {?LOG_NONE, []}))) /= 0).
-
--define(SHOULD_LOG(Level),
-    (lager_util:level_to_num(Level) band element(1, lager_config:get(loglevel, {?LOG_NONE, []}))) /= 0).
-
--define(NOTIFY(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}],
-            [])}
-        )).
-
-%% FOR INTERNAL USE ONLY
-%% internal non-blocking logging call
-%% there's some special handing for when we try to log (usually errors) while
-%% lager is still starting.
--ifdef(TEST).
--define(INT_LOG(Level, Format, Args),
-    case ?SHOULD_LOG(Level) of
-        true ->
-            ?NOTIFY(Level, self(), Format, Args);
-        _ ->
-            ok
-    end).
--else.
--define(INT_LOG(Level, Format, Args),
-    Self = self(),
-    %% do this in a spawn so we don't cause a deadlock calling gen_event:which_handlers
-    %% from a gen_event handler
-    spawn(fun() ->
-            case catch(gen_event:which_handlers(lager_event)) of
-                X when X == []; X == {'EXIT', noproc}; X == [lager_backend_throttle] ->
-                    %% there's no handlers yet or lager isn't running, try again
-                    %% in half a second.
-                    timer:sleep(500),
-                    ?NOTIFY(Level, Self, Format, Args);
-                _ ->
-                    case ?SHOULD_LOG(Level) of
-                        true ->
-                            ?NOTIFY(Level, Self, Format, Args);
-                        _ ->
-                            ok
-                    end
-            end
-    end)).
--endif.
-
--record(lager_shaper, {
-                  id :: any(),
-                  %% how many messages per second we try to deliver
-                  hwm = undefined :: 'undefined' | pos_integer(),
-                  %% how many messages we've received this second
-                  mps = 0 :: non_neg_integer(),
-                  %% the current second
-                  lasttime = os:timestamp() :: erlang:timestamp(),
-                  %% count of dropped messages this second
-                  dropped = 0 :: non_neg_integer(),
-                  %% If true, flush notify messages from msg queue at overload
-                  flush_queue = true :: boolean(),
-                  flush_threshold = 0 :: integer(),
-                  %% timer
-                  timer = make_ref() :: reference(),
-                  %% optional filter fun to avoid counting suppressed messages against HWM totals
-                  filter = fun(_) -> false end :: fun()
-                 }).
-
--type lager_shaper() :: #lager_shaper{}.

include/rum.hrl

@@ -0,0 +1,153 @@
+-define(RumDefTruncation, 4096).
+-define(RumDefTracer, lager_default_tracer).
+-define(RumDefSink, lager_event).
+-define(RumErrLogSink, error_logger_lager_event).
+
+-define(RumMetadata(Extras), [
+   {severity, info},
+   {pid, self()},
+   {node, node()},
+   {module, ?MODULE},
+   {function, ?FUNCTION_NAME},
+   {function_arity, ?FUNCTION_ARITY},
+   {file, ?FILE},
+   {line, ?LINE} | Extras
+]).
+
+
+-define(RumLevels, [debug, info, notice, warning, error, critical, alert, emergency, none]).
+
+%% 使用这些“功能”意味着，出于安全考虑，参数列表不会被截断
+-define(RumLevelsUnsafe, [{debug_unsafe, debug}, {info_unsafe, info}, {notice_unsafe, notice}, {warning_unsafe, warning}, {error_unsafe, error}, {critical_unsafe, critical}, {alert_unsafe, alert}, {emergency_unsafe, emergency}]).
+
+-define(DEBUG, 128).
+-define(INFO, 64).
+-define(NOTICE, 32).
+-define(WARNING, 16).
+-define(ERROR, 8).
+-define(CRITICAL, 4).
+-define(ALERT, 2).
+-define(EMERGENCY, 1).
+-define(LOG_NONE, 0).
+
+-define(RumLevelToNum(Level),
+   case Level of
+      debug -> ?DEBUG;
+      info -> ?INFO;
+      notice -> ?NOTICE;
+      warning -> ?WARNING;
+      error -> ?ERROR;
+      critical -> ?CRITICAL;
+      alert -> ?ALERT;
+      emergency -> ?EMERGENCY
+   end).
+
+-define(RumNumToLevel(Num),
+   case Num of
+      ?DEBUG -> debug;
+      ?INFO -> info;
+      ?NOTICE -> notice;
+      ?WARNING -> warning;
+      ?ERROR -> error;
+      ?CRITICAL -> critical;
+      ?ALERT -> alert;
+      ?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(Level), (rumUtil:level_to_num(Level) band element(1, lager_config: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}], [])})).
+
+%%仅供内部使用仅内部非阻塞日志记录调用，当我们仍在启动大型啤酒时尝试进行日志记录（通常为错误）时，会有一些特殊处理。
+-ifdef(TEST).
+-define(INT_LOG(Level, Format, Args),
+   case ?RunShouldLog(Level) of
+      true ->
+         ?RunNotify(Level, self(), Format, Args);
+      _ ->
+         ok
+   end).
+-else.
+-define(INT_LOG(Level, Format, Args),
+   Self = self(),
+   %% do this in a spawn so we don't cause a deadlock calling gen_event:which_handlers
+   %% from a gen_event handler
+   spawn(fun() ->
+      case catch (gen_event:which_handlers(lager_event)) of
+         X when X == []; X == {'EXIT', noproc}; X == [lager_backend_throttle] ->
+            %% there's no handlers yet or lager isn't running, try again
+            %% in half a second.
+            timer:sleep(500),
+            ?RunNotify(Level, Self, Format, Args);
+         _ ->
+            case ?RunShouldLog(Level) of
+               true ->
+                  ?RunNotify(Level, Self, Format, Args);
+               _ ->
+                  ok
+            end
+      end
+         end)).
+-endif.
+
+-define(rumLog(Severity, Format, Args, Safety),
+   ?rumLog(?RumDefSink, Severity, ?RumMetadata(lager:md()), Format, Args, ?RumDefTruncation, Safety)).
+
+-define(rumLog(Severity, Metadata, Format, Args, Safety),
+   ?rumLog(?RumDefSink, Severity, ?RumMetadata(Metadata ++ lager:md()), Format, Args, ?RumDefTruncation, Safety)).
+
+-define(rumLog(Sink, Severity, Metadata, Format, Args, Size, Safety),
+   _ = lager:dispatch_log(Sink, Severity, Metadata, Format, Args, Size, Safety)).
+
+-define(rumDebug(Format, Args), ?rumLog(debug, Format, Args, safe)).
+-define(rumDebug(Metadata, Format, Args), ?rumLog(debug, Metadata, Format, Args, safe)).
+
+-define(rumInfo(Format, Args), ?rumLog(info, Format, Args, safe)).
+-define(rumInfo(Metadata, Format, Args), ?rumLog(info, Metadata, Format, Args, safe)).
+
+-define(rumNotice(Format, Args), ?rumLog(notice, Format, Args, safe)).
+-define(rumNotice(Metadata, Format, Args), ?rumLog(notice, Metadata, Format, Args, safe)).
+
+-define(rumWarning(Format, Args), ?rumLog(warning, Format, Args, safe)).
+-define(rumWarning(Metadata, Format, Args), ?rumLog(warning, Metadata, Format, Args, safe)).
+
+-define(rumError(Format, Args), ?rumLog(error, Format, Args, safe)).
+-define(rumError(Metadata, Format, Args), ?rumLog(error, Metadata, Format, Args, safe)).
+
+-define(rumCritical(Format, Args), ?rumLog(critical, Format, Args, safe)).
+-define(rumCritical(Metadata, Format, Args), ?rumLog(critical, Metadata, Format, Args, safe)).
+
+-define(rumAlert(Format, Args), ?rumLog(alert, Format, Args, safe)).
+-define(rumAlert(Metadata, Format, Args), ?rumLog(alert, Metadata, Format, Args, safe)).
+
+-define(rumEmergency(Format, Args), ?rumLog(emergency, Format, Args, safe)).
+-define(rumEmergency(Metadata, Format, Args), ?rumLog(emergency, Metadata, Format, Args, safe)).
+
+-define(rumNone(Format, Args), ?rumLog(none, Format, Args, safe)).
+-define(rumNone(Metadata, Format, Args), ?rumLog(none, Metadata, Format, Args, safe)).
+
+-record(rumShaper, {
+   id :: any()
+   %% 每秒我们尝试传递多少消息
+   , hwm = undefined :: 'undefined' | pos_integer()
+   %% 这秒内我们收到了多少条消息
+   , mps = 0 :: non_neg_integer()
+   %% 当前秒
+   , lastTime = os:timestamp() :: erlang:timestamp()
+   %% 此秒内丢弃的消息数
+   , dropped = 0 :: non_neg_integer()
+   %% If true, flush notify messages from msg queue at overload
+   %% 如果为true，则在过载时刷新来自消息队列的通知消息
+   , flushQueue = true :: boolean()
+   , flushThreshold = 0 :: integer()
+   %% timer
+   , timer = make_ref() :: reference()
+   %% optional filter fun to avoid counting suppressed messages against HWM totals
+   %% 可选的过滤器函数，以避免对HWM总数计算抑制消息
+   , filter = fun(_) -> false end :: fun()
+}).
+
+-type rumShaper() :: #rumShaper{}.

src/eRum.app.src

@@ -1,15 +1,55 @@
 {application, eRum,
- [{description, "An OTP application"},
-  {vsn, "0.1.0"},
-  {registered, []},
-  {mod, {eRum_app, []}},
-  {applications,
-   [kernel,
-    stdlib
-   ]},
-  {env,[]},
-  {modules, []},
+   [
+      {description, "Erlang logger application"},
+      {vsn, "0.1.0"},
+      {modules, []},
+      {applications, [kernel, stdlib, goldrush]},
+      {registered, [eRum_sup, lager_event, lager_crash_log, lager_handler_watcher_sup]},
+      {mod, {eRum_app, []}},
+      {env, [
+      %% Note: application:start(lager) overwrites previously defined environment variables thus declaration of default handlers is done at lager_app.erl
+
+      %% What colors to use with what log levels
+         {colored, false},
+         {colors, [
+            {debug, "\e[0;38m"},
+            {info, "\e[1;37m"},
+            {notice, "\e[1;36m"},
+            {warning, "\e[1;33m"},
+            {error, "\e[1;31m"},
+            {critical, "\e[1;35m"},
+            {alert, "\e[1;44m"},
+            {emergency, "\e[1;41m"}]},
+
+         %% Whether to write a crash log, and where. False means no crash logger.
+         {crash_log, "log/crash.log"},
+         %% Maximum size in bytes of events in the crash log - defaults to 65536
+         {crash_log_msg_size, 65536},
+         %% Maximum size of the crash log in bytes, before its rotated, set
+         %% to 0 to disable rotation - default is 0
+         {crash_log_size, 10485760},
+         %% What time to rotate the crash log - default is no time
+         %% rotation. See the README for a description of this format.
+         {crash_log_date, "$D0"},
+         %% Number of rotated crash logs to keep, 0 means keep only the
+         %% current one - default is 0
+         {crash_log_count, 5},
+         %% Crash Log Rotator Module - default is lager_rotator_default
+         {crash_log_rotator, lager_rotator_default},
+         %% Whether to redirect error_logger messages into the default lager_event sink - defaults to true
+         {error_logger_redirect, true},
+         %% How many messages per second to allow from error_logger before we start dropping them
+         {error_logger_hwm, 50},
+         %% How big the gen_event mailbox can get before it is
+         %% switched into sync mode.  This value only applies to
+         %% the default sink; extra sinks can supply their own.
+         {async_threshold, 20},
+         %% Switch back to async mode, when gen_event mailbox size
+         %% decrease from `async_threshold' to async_threshold -
+         %% async_threshold_window. This value only applies to the
+         %% default sink; extra sinks can supply their own.
+         {async_threshold_window, 5}
+      ]},
+      {licenses, ["MIT License"]}
+   ]}.
 
-  {licenses, ["Apache 2.0"]},
-  {links, []}
- ]}.

src/eRum_app.erl

@@ -1,18 +1,406 @@
-%%%-------------------------------------------------------------------
-%% @doc eRum public API
-%% @end
-%%%-------------------------------------------------------------------
-
 -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]).
+
+%% The `application:get_env/3` compatibility wrapper was useful
+%% for other modules in r15 and before
+-export([get_env/3]).
+
+-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}]
+        }
+    ]).
+
+start() ->
+    application:start(lager).
+
+start_throttle(Sink, Threshold, Window) ->
+    _ = supervisor:start_child(lager_handler_watcher_sup,
+        [Sink, ?THROTTLE, [Threshold, Window]]),
+    ok.
+
+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]),
+    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]),
+    throw({error, bad_config});
+determine_async_behavior(Sink, Threshold, Window) ->
+    start_throttle(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]),
+    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,
+            expand_handlers(Handlers))),
+    ok.
+
+start_handler(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,
+    case ordsets:is_element(F, Fs) of
+        true ->
+            error_logger:error_msg(
+                "Cannot have same file (~p) in multiple file backends~n", [F]),
+            throw({error, bad_config});
+        false ->
+            put(?FILENAMES,
+                ordsets:add_element(F, Fs))
+    end,
+    ok;
+check_handler_config(_Handler, Config) when is_list(Config) orelse is_atom(Config) ->
+    ok;
+check_handler_config(Handler, _BadConfig) ->
+    throw({error, {bad_config, Handler}}).
+
+clean_up_config_checks() ->
+    erase(?FILENAMES).
+
+interpret_hwm(undefined) ->
+    undefined;
+interpret_hwm(HWM) when not is_integer(HWM) orelse HWM < 0 ->
+    _ = lager:log(warning, self(), "Invalid error_logger high water mark: ~p, disabling", [HWM]),
+    undefined;
+interpret_hwm(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 ->
+    _ = supervisor:start_child(lager_handler_watcher_sup, [Sink, lager_manager_killer,
+        [HWM, ReinstallTimer]]);
+maybe_install_sink_killer(_Sink, HWM, ReinstallTimer) ->
+    error_logger:error_msg("Invalid value for 'killer_hwm': ~p or 'killer_reinstall_after': ~p", [HWM, ReinstallTimer]),
+    throw({error, bad_config}).
+
+-spec start_error_logger_handler(boolean(), pos_integer(), list()) -> list().
+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,
+
+    case whereis(error_logger) of
+        undefined ->
+            %% On OTP 21 and above, error_logger is deprecated in favor of 'logger'
+            %% As a band-aid, boot up error_logger anyway and install it as a logger handler
+            %% we can't use error_logger:add_report_handler because we want supervision of the handler
+            %% so we have to manually add the logger handler
+            %%
+            %% Longer term we should be installing a logger handler instead, but this will bridge the gap
+            %% for now.
+            _ = error_logger:start(),
+            _ = logger:add_handler(error_logger,error_logger,#{level=>info,filter_default=>log}),
+            ok = maybe_remove_logger_handler();
+        _ ->
+            ok
+    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.
+
+%% On OTP 21.1 and higher we need to remove the `default' handler.
+%% But it might not exist, so we will wrap this in a try-catch
+%% block
+maybe_remove_logger_handler() ->
+    try
+        ok = logger:remove_handler(default)
+    catch
+        error:undef -> ok;
+        Err:Reason ->
+            error_logger:error_msg("calling logger:remove_handler(default) failed: ~p ~p",
+                [Err, Reason])
+    end.
+
+configure_sink(Sink, SinkDef) ->
+    lager_config:new_sink(Sink),
+    ChildId = rumUtil:make_internal_sink_name(Sink),
+    _ = supervisor:start_child(eRum_sup,
+        {ChildId,
+            {gen_event, start_link,
+                [{local, Sink}]},
+            permanent, 5000, worker, dynamic}),
+    determine_async_behavior(Sink, proplists:get_value(async_threshold, SinkDef),
+        proplists:get_value(async_threshold_window, SinkDef)
+    ),
+    _ = maybe_install_sink_killer(Sink, proplists:get_value(killer_hwm, SinkDef),
+        proplists:get_value(killer_reinstall_after, SinkDef)),
+    start_handlers(Sink,
+        proplists:get_value(handlers, SinkDef, [])),
 
--export([start/2, stop/1]).
+    lager:update_loglevel_config(Sink).
+
+
+configure_extra_sinks(Sinks) ->
+    lists:foreach(fun({Sink, Proplist}) -> configure_sink(Sink, Proplist) end,
+        Sinks).
+
+-spec get_env(atom(), atom(), term()) -> term().
+get_env(Application, Key, Default) ->
+    application:get_env(Application, Key, Default).
 
 start(_StartType, _StartArgs) ->
-    eRum_sup:start_link().
+    {ok, Pid} = eRum_sup:start_link(),
+    SavedHandlers = boot(),
+    _ = boot('__all_extra'),
+    _ = boot('__traces'),
+    clean_up_config_checks(),
+    {ok, Pid, SavedHandlers}.
+
+boot() ->
+    %% Handle the default sink.
+    determine_async_behavior(?RumDefSink,
+        application:get_env(lager, async_threshold, undefined),
+        application:get_env(lager, async_threshold_window, undefined)),
+
+    _ = maybe_install_sink_killer(?RumDefSink, application:get_env(lager, killer_hwm, undefined),
+        application:get_env(lager, killer_reinstall_after, undefined)),
+
+    start_handlers(?RumDefSink,
+        application:get_env(lager, handlers, ?DEFAULT_HANDLER_CONF)),
+
+    lager:update_loglevel_config(?RumDefSink),
+
+    SavedHandlers = start_error_logger_handler(
+        application:get_env(lager, error_logger_redirect, true),
+        interpret_hwm(application:get_env(lager, error_logger_hwm, 0)),
+        application:get_env(lager, error_logger_whitelist, [])
+    ),
+
+    SavedHandlers.
+
+boot('__traces') ->
+    _ = rumUtil:trace_filter(none),
+    ok = add_configured_traces();
 
-stop(_State) ->
+boot('__all_extra') ->
+    configure_extra_sinks(application:get_env(lager, extra_sinks, []));
+
+boot(?RumDefSink) -> boot();
+boot(Sink) ->
+    AllSinksDef = application:get_env(lager, extra_sinks, []),
+    boot_sink(Sink, lists:keyfind(Sink, 1, AllSinksDef)).
+
+boot_sink(Sink, {Sink, Def}) ->
+    configure_sink(Sink, Def);
+boot_sink(Sink, false) ->
+    configure_sink(Sink, []).
+
+stop(Handlers) ->
+    lists:foreach(fun(Handler) ->
+        error_logger:add_report_handler(Handler)
+                  end, Handlers),
+    lager_config:cleanup().
+
+expand_handlers([]) ->
+    [];
+expand_handlers([{lager_file_backend, [{Key, _Value}|_]=Config}|T]) when is_atom(Key) ->
+    %% this is definitely a new-style config, no expansion needed
+    [maybe_make_handler_id(lager_file_backend, Config) | expand_handlers(T)];
+expand_handlers([{lager_file_backend, Configs}|T]) ->
+    ?INT_LOG(notice, "Deprecated lager_file_backend config detected, please consider updating it", []),
+    [ {lager_file_backend:config_to_id(Config), Config} || Config <- Configs] ++
+    expand_handlers(T);
+expand_handlers([{Mod, Config}|T]) when is_atom(Mod) ->
+    [maybe_make_handler_id(Mod, Config) | expand_handlers(T)];
+expand_handlers([H|T]) ->
+    [H | expand_handlers(T)].
+
+add_configured_traces() ->
+    Traces = case application:get_env(lager, traces) of
+                 undefined ->
+                     [];
+                 {ok, TraceVal} ->
+                     TraceVal
+             end,
+
+    lists:foreach(fun start_configured_trace/1, Traces),
     ok.
 
-%% internal functions
+start_configured_trace({Handler, Filter}) ->
+    {ok, _} = lager:trace(Handler, Filter);
+start_configured_trace({Handler, Filter, Level}) when is_atom(Level) ->
+    {ok, _} = lager:trace(Handler, Filter, Level).
+
+maybe_make_handler_id(Mod, Config) ->
+    %% Allow the backend to generate a gen_event handler id, if it wants to.
+    %% We don't use erlang:function_exported here because that requires the module
+    %% already be loaded, which is unlikely at this phase of startup. Using code:load
+    %% caused undesirable side-effects with generating code-coverage reports.
+    try Mod:config_to_id(Config) of
+        Id ->
+            {Id, 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.

src/eRum_sup.erl

@@ -1,35 +1,73 @@
-%%%-------------------------------------------------------------------
-%% @doc eRum top level supervisor.
-%% @end
-%%%-------------------------------------------------------------------
-
 -module(eRum_sup).
 
 -behaviour(supervisor).
 
+%% API
 -export([start_link/0]).
 
+%% Callbacks
 -export([init/1]).
 
--define(SERVER, ?MODULE).
-
 start_link() ->
-    supervisor:start_link({local, ?SERVER}, ?MODULE, []).
-
-%% sup_flags() = #{strategy => strategy(),         % optional
-%%                 intensity => non_neg_integer(), % optional
-%%                 period => pos_integer()}        % optional
-%% child_spec() = #{id => child_id(),       % mandatory
-%%                  start => mfargs(),      % mandatory
-%%                  restart => restart(),   % optional
-%%                  shutdown => shutdown(), % optional
-%%                  type => worker(),       % optional
-%%                  modules => modules()}   % optional
+   supervisor:start_link({local, ?MODULE}, ?MODULE, []).
+
 init([]) ->
-    SupFlags = #{strategy => one_for_all,
-                 intensity => 0,
-                 period => 1},
-    ChildSpecs = [],
-    {ok, {SupFlags, ChildSpecs}}.
+   %% set up the config, is safe even during relups
+   lager_config: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]}],
+
+   CrashLog = decide_crash_log(application:get_env(lager, crash_log, false)),
+
+   {ok, {{one_for_one, 10, 60},
+         Children ++ CrashLog
+   }}.
+
+validate_positive({ok, Val}, _Default) when is_integer(Val) andalso Val >= 0 ->
+   Val;
+validate_positive(_Val, Default) ->
+   Default.
+
+determine_rotation_date({ok, ""}) ->
+   undefined;
+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]),
+         undefined
+   end;
+determine_rotation_date(_) ->
+   undefined.
+
+determine_rotator_mod({ok, Mod}, _Default) when is_atom(Mod) ->
+   Mod;
+determine_rotator_mod(_, Default) ->
+   Default.
+
+decide_crash_log(undefined) ->
+   [];
+decide_crash_log(false) ->
+   [];
+decide_crash_log(File) ->
+   MaxBytes = validate_positive(application:get_env(lager, crash_log_msg_size), 65536),
+   RotationSize = validate_positive(application:get_env(lager, crash_log_size), 0),
+   RotationCount = validate_positive(application:get_env(lager, crash_log_count), 0),
+
+   RotationDate = determine_rotation_date(application:get_env(lager, crash_log_date)),
+   RotationMod = determine_rotator_mod(application:get_env(lager, crash_log_rotator), lager_rotator_default),
+
+
+   [{lager_crash_log, {lager_crash_log, start_link, [File, MaxBytes,
+      RotationSize, RotationDate, RotationCount, RotationMod]},
+      permanent, 5000, worker, [lager_crash_log]}].
 
-%% internal functions

src/error_logger_lager_h.erl

@@ -23,7 +23,7 @@
 
 -module(error_logger_lager_h).
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -behaviour(gen_event).
 
@@ -35,14 +35,14 @@
 
 -record(state, {
         sink :: atom(),
-        shaper :: lager_shaper(),
+        shaper :: rumShaper(),
         %% group leader strategy
         groupleader_strategy :: handle | ignore | mirror,
         raw :: boolean()
     }).
 
 -define(LOGMSG(Sink, Level, Pid, Msg),
-    case ?SHOULD_LOG(Sink, Level) of
+    case ?RunShouldLog(Sink, Level) of
         true ->
             _ =lager:log(Sink, Level, Pid, Msg, []),
             logged;
@@ -50,7 +50,7 @@
     end).
 
 -define(LOGFMT(Sink, Level, Pid, Fmt, Args),
-    case ?SHOULD_LOG(Sink, Level) of
+    case ?RunShouldLog(Sink, Level) of
         true ->
             _ = lager:log(Sink, Level, Pid, Fmt, Args),
             logged;
@@ -73,13 +73,13 @@ set_high_water(N) ->
 init([HighWaterMark, GlStrategy]) ->
     Flush = application:get_env(lager, error_logger_flush_queue, true),
     FlushThr = application:get_env(lager, error_logger_flush_threshold, 0),
-    Shaper = #lager_shaper{hwm=HighWaterMark, flush_queue = Flush, flush_threshold = FlushThr, filter=shaper_fun(), id=?MODULE},
+    Shaper = #rumShaper{hwm=HighWaterMark, flushQueue = Flush, flushThreshold = FlushThr, filter=shaper_fun(), id=?MODULE},
     Raw = application:get_env(lager, error_logger_format_raw, false),
     Sink = configured_sink(),
     {ok, #state{sink=Sink, shaper=Shaper, groupleader_strategy=GlStrategy, raw=Raw}}.
 
 handle_call({set_high_water, N}, #state{shaper=Shaper} = State) ->
-    NewShaper = Shaper#lager_shaper{hwm=N},
+    NewShaper = Shaper#rumShaper{hwm=N},
     {ok, ok, State#state{shaper = NewShaper}};
 handle_call(_Request, State) ->
     {ok, unknown_call, State}.
@@ -112,28 +112,28 @@ suppress_supervisor_start(_) ->
     false.
 
 handle_event(Event, #state{sink=Sink, shaper=Shaper} = State) ->
-    case lager_util:check_hwm(Shaper, Event) of
+    case rumUtil:check_hwm(Shaper, Event) of
         {true, 0, NewShaper} ->
             eval_gl(Event, State#state{shaper=NewShaper});
-        {true, Drop, #lager_shaper{hwm=Hwm} = NewShaper} when Drop > 0 ->
+        {true, Drop, #rumShaper{hwm=Hwm} = NewShaper} when Drop > 0 ->
             ?LOGFMT(Sink, warning, self(),
                 "lager_error_logger_h dropped ~p messages in the last second that exceeded the limit of ~p messages/sec",
                 [Drop, Hwm]),
             eval_gl(Event, State#state{shaper=NewShaper});
-        {false, _, #lager_shaper{dropped=D} = NewShaper} ->
-            {ok, State#state{shaper=NewShaper#lager_shaper{dropped=D+1}}}
+        {false, _, #rumShaper{dropped=D} = NewShaper} ->
+            {ok, State#state{shaper=NewShaper#rumShaper{dropped=D+1}}}
     end.
 
 handle_info({shaper_expired, ?MODULE}, #state{sink=Sink, shaper=Shaper} = State) ->
-    case Shaper#lager_shaper.dropped of
+    case Shaper#rumShaper.dropped of
         0 ->
             ok;
         Dropped ->
             ?LOGFMT(Sink, warning, self(),
                     "lager_error_logger_h dropped ~p messages in the last second that exceeded the limit of ~p messages/sec",
-                    [Dropped, Shaper#lager_shaper.hwm])
+                    [Dropped, Shaper#rumShaper.hwm])
     end,
-    {ok, State#state{shaper=Shaper#lager_shaper{dropped=0, mps=0, lasttime=os:timestamp()}}};
+    {ok, State#state{shaper=Shaper#rumShaper{dropped=0, mps=0, lastTime =os:timestamp()}}};
 handle_info(_Info, State) ->
     {ok, State}.
 
@@ -158,9 +158,9 @@ code_change(_OldVsn, State, _Extra) ->
 %% internal functions
 
 configured_sink() ->
-    case proplists:get_value(?ERROR_LOGGER_SINK, application:get_env(lager, extra_sinks, [])) of
-        undefined -> ?DEFAULT_SINK;
-        _ -> ?ERROR_LOGGER_SINK
+    case proplists:get_value(?RumErrLogSink, application:get_env(lager, extra_sinks, [])) of
+        undefined -> ?RumDefSink;
+        _ -> ?RumErrLogSink
     end.
 
 eval_gl(Event, #state{groupleader_strategy=GlStrategy0}=State) when is_pid(element(2, Event)) ->
@@ -366,8 +366,8 @@ log_event(Event, #state{sink=Sink} = State) ->
         no_log ->
             Shaper = State#state.shaper,
             {ok, State#state{
-                   shaper = Shaper#lager_shaper{
-                              mps = Shaper#lager_shaper.mps - 1
+                   shaper = Shaper#rumShaper{
+                              mps = Shaper#rumShaper.mps - 1
                              }
                   }
             }
@@ -589,20 +589,20 @@ format_args([H|T], FmtAcc, ArgsAcc) ->
 print_silly_list(L) when is_list(L) ->
     case lager_stdlib:string_p(L) of
         true ->
-            lager_trunc_io:format("~s", [L], ?DEFAULT_TRUNCATION);
+            lager_trunc_io:format("~s", [L], ?RumDefTruncation);
         _ ->
             print_silly_list(L, [], [])
     end;
 print_silly_list(L) ->
-    {Str, _} = lager_trunc_io:print(L, ?DEFAULT_TRUNCATION),
+    {Str, _} = lager_trunc_io:print(L, ?RumDefTruncation),
     Str.
 
 print_silly_list([], Fmt, Acc) ->
     lager_trunc_io:format(string:join(lists:reverse(Fmt), ", "),
-        lists:reverse(Acc), ?DEFAULT_TRUNCATION);
-print_silly_list([{K,V}|T], Fmt, Acc) ->
+        lists:reverse(Acc), ?RumDefTruncation);
+print_silly_list([{K, V} | T], Fmt, Acc) ->
     print_silly_list(T, ["~p: ~p" | Fmt], [V, K | Acc]);
-print_silly_list([H|T], Fmt, Acc) ->
+print_silly_list([H | T], Fmt, Acc) ->
     print_silly_list(T, ["~p" | Fmt], [H | Acc]).
 
 print_val(Val) ->

src/lager.app.src

@@ -1,64 +0,0 @@
-%% -*- tab-width: 4;erlang-indent-level: 4;indent-tabs-mode: nil -*-
-%% ex: ts=4 sw=4 et
-{application, lager,
- [
-  {description, "Erlang logging framework"},
-  {vsn, "3.8.1"},
-  {modules, []},
-  {applications, [
-                  kernel,
-                  stdlib,
-                  goldrush
-                 ]},
-  {registered, [lager_sup, lager_event, lager_crash_log, lager_handler_watcher_sup]},
-  {mod, {lager_app, []}},
-  {env, [
-            %% Note: application:start(lager) overwrites previously defined environment variables
-            %%       thus declaration of default handlers is done at lager_app.erl
-
-            %% What colors to use with what log levels
-            {colored, false},
-            {colors, [
-              {debug,     "\e[0;38m" },
-              {info,      "\e[1;37m" },
-              {notice,    "\e[1;36m" },
-              {warning,   "\e[1;33m" },
-              {error,     "\e[1;31m" },
-              {critical,  "\e[1;35m" },
-              {alert,     "\e[1;44m" },
-              {emergency, "\e[1;41m" }
-
-            ]},
-
-            %% Whether to write a crash log, and where. False means no crash logger.
-            {crash_log, "log/crash.log"},
-            %% Maximum size in bytes of events in the crash log - defaults to 65536
-            {crash_log_msg_size, 65536},
-            %% Maximum size of the crash log in bytes, before its rotated, set
-            %% to 0 to disable rotation - default is 0
-            {crash_log_size, 10485760},
-            %% What time to rotate the crash log - default is no time
-            %% rotation. See the README for a description of this format.
-            {crash_log_date, "$D0"},
-            %% Number of rotated crash logs to keep, 0 means keep only the
-            %% current one - default is 0
-            {crash_log_count, 5},
-            %% Crash Log Rotator Module - default is lager_rotator_default
-            {crash_log_rotator, lager_rotator_default},
-            %% Whether to redirect error_logger messages into the default lager_event sink - defaults to true
-            {error_logger_redirect, true},
-            %% How many messages per second to allow from error_logger before we start dropping them
-            {error_logger_hwm, 50},
-            %% How big the gen_event mailbox can get before it is
-            %% switched into sync mode.  This value only applies to
-            %% the default sink; extra sinks can supply their own.
-            {async_threshold, 20},
-            %% Switch back to async mode, when gen_event mailbox size
-            %% decrease from `async_threshold' to async_threshold -
-            %% async_threshold_window. This value only applies to the
-            %% default sink; extra sinks can supply their own.
-            {async_threshold_window, 5}
-        ]},
-  {licenses, ["Apache 2"]},
-  {links, [{"Github", "https://github.com/erlang-lager/lager"}]}
- ]}.

src/lager.erl

@@ -18,7 +18,7 @@
 
 -module(lager).
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -define(LAGER_MD_KEY, '__lager_metadata').
 -define(TRACE_SINK, '__trace_sink').
@@ -118,15 +118,15 @@ md(_) ->
 %% this is the same check that the parse transform bakes into the module at compile time
 %% see lager_transform (lines 173-216)
 dispatch_log(Sink, Severity, Metadata, Format, Args, Size, Safety) when is_atom(Severity)->
-    SeverityAsInt=lager_util:level_to_num(Severity),
-    case {whereis(Sink), whereis(?DEFAULT_SINK), lager_config: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 /= [] ) ->
-            do_log(Severity, Metadata, Format, Args, Size, SeverityAsInt, Level, Traces, Sink, SinkPid);
-         {SinkPid, _LagerEventPid1, {Level, Traces}} when Safety =:= unsafe andalso ( (Level band SeverityAsInt) /= 0 orelse Traces /= [] ) ->
-            do_log_unsafe(Severity, Metadata, Format, Args, Size, SeverityAsInt, Level, Traces, Sink, SinkPid);
-         _ -> ok
+    SeverityAsInt= rumUtil:level_to_num(Severity),
+    case {whereis(Sink), whereis(?RumDefSink), lager_config: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 /= []) ->
+          do_log(Severity, Metadata, Format, Args, Size, SeverityAsInt, Level, Traces, Sink, SinkPid);
+       {SinkPid, _LagerEventPid1, {Level, Traces}} when Safety =:= unsafe andalso ((Level band SeverityAsInt) /= 0 orelse Traces /= []) ->
+          do_log_unsafe(Severity, Metadata, Format, Args, Size, SeverityAsInt, Level, Traces, Sink, SinkPid);
+       _ -> ok
     end.
 
 %% @private Should only be called externally from code generated from the parse transform
@@ -139,7 +139,7 @@ do_log_impl(Severity, Metadata, Format, Args, SeverityAsInt, LevelThreshold, Tra
         [] ->
             {[], undefined};
         _ ->
-            {lager_util:check_traces(Metadata,SeverityAsInt,TraceFilters,[]), whereis(?TRACE_SINK)}
+            {rumUtil:check_traces(Metadata,SeverityAsInt,TraceFilters,[]), whereis(?TRACE_SINK)}
     end,
     case (LevelThreshold band SeverityAsInt) /= 0 orelse Destinations /= [] of
         true ->
@@ -180,12 +180,12 @@ dispatch_log(Severity, _Module, _Function, _Line, _Pid, Metadata, Format, Args,
 
 %% backwards compatible with beams compiled with lager 2.x
 dispatch_log(Severity, Metadata, Format, Args, Size) ->
-    dispatch_log(?DEFAULT_SINK, Severity, Metadata, Format, Args, Size, safe).
+   dispatch_log(?RumDefSink, Severity, Metadata, Format, Args, Size, safe).
 
 %% backwards compatible with beams compiled with lager 2.x
 do_log(Severity, Metadata, Format, Args, Size, SeverityAsInt, LevelThreshold, TraceFilters, SinkPid) ->
-    do_log(Severity, Metadata, Format, Args, Size, SeverityAsInt,
-           LevelThreshold, TraceFilters, ?DEFAULT_SINK, SinkPid).
+   do_log(Severity, Metadata, Format, Args, Size, SeverityAsInt,
+      LevelThreshold, TraceFilters, ?RumDefSink, SinkPid).
 
 
 %% TODO:
@@ -195,37 +195,37 @@ do_log(Severity, Metadata, Format, Args, Size, SeverityAsInt, LevelThreshold, Tr
 %% @doc Manually log a message into lager without using the parse transform.
 -spec log(log_level(), pid() | atom() | [tuple(),...], list()) -> ok | {error, lager_not_running}.
 log(Level, Pid, Message) when is_pid(Pid); is_atom(Pid) ->
-    dispatch_log(Level, [{pid,Pid}], Message, [], ?DEFAULT_TRUNCATION);
+   dispatch_log(Level, [{pid, Pid}], Message, [], ?RumDefTruncation);
 log(Level, Metadata, Message) when is_list(Metadata) ->
-    dispatch_log(Level, Metadata, Message, [], ?DEFAULT_TRUNCATION).
+   dispatch_log(Level, Metadata, Message, [], ?RumDefTruncation).
 
 %% @doc Manually log a message into lager without using the parse transform.
 -spec log(log_level(), pid() | atom() | [tuple(),...], string(), list()) -> ok | {error, lager_not_running}.
 log(Level, Pid, Format, Args) when is_pid(Pid); is_atom(Pid) ->
-    dispatch_log(Level, [{pid,Pid}], Format, Args, ?DEFAULT_TRUNCATION);
+   dispatch_log(Level, [{pid, Pid}], Format, Args, ?RumDefTruncation);
 log(Level, Metadata, Format, Args) when is_list(Metadata) ->
-    dispatch_log(Level, Metadata, Format, Args, ?DEFAULT_TRUNCATION).
+   dispatch_log(Level, Metadata, Format, Args, ?RumDefTruncation).
 
 log_unsafe(Level, Metadata, Format, Args) when is_list(Metadata) ->
-    dispatch_log(?DEFAULT_SINK, Level, Metadata, Format, Args, ?DEFAULT_TRUNCATION, unsafe).
+   dispatch_log(?RumDefSink, Level, Metadata, Format, Args, ?RumDefTruncation, unsafe).
 
 
 %% @doc Manually log a message into lager without using the parse transform.
 -spec log(atom(), log_level(), pid() | atom() | [tuple(),...], string(), list()) -> ok | {error, lager_not_running}.
 log(Sink, Level, Pid, Format, Args) when is_pid(Pid); is_atom(Pid) ->
-    dispatch_log(Sink, Level, [{pid,Pid}], Format, Args, ?DEFAULT_TRUNCATION, safe);
+   dispatch_log(Sink, Level, [{pid, Pid}], Format, Args, ?RumDefTruncation, safe);
 log(Sink, Level, Metadata, Format, Args) when is_list(Metadata) ->
-    dispatch_log(Sink, Level, Metadata, Format, Args, ?DEFAULT_TRUNCATION, safe).
+   dispatch_log(Sink, Level, Metadata, Format, Args, ?RumDefTruncation, safe).
 
 validate_trace_filters(Filters, Level, Backend) ->
-    Sink = proplists:get_value(sink, Filters, ?DEFAULT_SINK),
-    {Sink,
-     lager_util:validate_trace({
-                                 proplists:delete(sink, Filters),
-                                 Level,
-                                 Backend
-                               })
-    }.
+   Sink = proplists:get_value(sink, Filters, ?RumDefSink),
+   {Sink,
+      rumUtil:validate_trace({
+         proplists:delete(sink, Filters),
+         Level,
+         Backend
+      })
+   }.
 
 trace_file(File, Filter) ->
     trace_file(File, Filter, debug, []).
@@ -237,12 +237,12 @@ trace_file(File, Filter, Options) when is_list(Options) ->
     trace_file(File, Filter, debug, Options).
 
 trace_file(File, Filter, Level, Options) ->
-    FileName = lager_util:expand_path(File),
+    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, []),
             %% check if this file backend is already installed
-            Res = case lager_util:find_file(FileName, Handlers) of
+            Res = case rumUtil:find_file(FileName, Handlers) of
                       false ->
                           %% install the handler
                           LogFileConfig =
@@ -316,7 +316,7 @@ stop_trace({Backend, Filter, Level}) ->
 stop_trace_int({_Filter, _Level, Backend} = Trace, Sink) ->
     {Level, Traces} = lager_config:get({Sink, loglevel}),
     NewTraces =  lists:delete(Trace, Traces),
-    _ = lager_util:trace_filter([ element(1, T) || T <- NewTraces ]),
+    _ = rumUtil:trace_filter([ element(1, T) || T <- NewTraces ]),
     %MinLevel = minimum_loglevel(get_loglevels() ++ get_trace_levels(NewTraces)),
     lager_config:set({Sink, loglevel}, {Level, NewTraces}),
     case get_loglevel(Sink, Backend) of
@@ -362,7 +362,7 @@ clear_trace_by_destination(ID) ->
 clear_all_traces() ->
     Handlers = lager_config:global_get(handlers, []),
     clear_traces_by_sink(list_all_sinks()),
-    _ = lager_util:trace_filter(none),
+    _ = rumUtil:trace_filter(none),
     lager_config:global_set(handlers,
                             lists:filter(
       fun({Handler, _Watcher, Sink}) ->
@@ -402,29 +402,29 @@ status() ->
         [begin
              LevelName = case Level of
                  {mask, Mask} ->
-                     case lager_util:mask_to_levels(Mask) of
+                     case rumUtil:mask_to_levels(Mask) of
                          [] -> none;
                          Levels -> hd(Levels)
                      end;
                  Num ->
-                     lager_util:num_to_level(Num)
+                     rumUtil:num_to_level(Num)
              end,
              io_lib:format("Tracing messages matching ~p (sink ~s) at level ~p to ~p\n",
                            [Filter, Sink, LevelName, Destination])
          end || {Sink, {Filter, Level, Destination}} <- Traces],
          [
          "Tracing Reductions:\n",
-            case ?DEFAULT_TRACER:info('query') of
-                {null, false} -> "";
-                Query -> io_lib:format("~p~n", [Query])
+            case ?RumDefTracer:info('query') of
+               {null, false} -> "";
+               Query -> io_lib:format("~p~n", [Query])
             end
          ],
          [
           "Tracing Statistics:\n ",
               [ begin
-                    [" ", atom_to_list(Table), ": ",
-                     integer_to_list(?DEFAULT_TRACER:info(Table) div TraceCount),
-                     "\n"]
+                   [" ", atom_to_list(Table), ": ",
+                      integer_to_list(?RumDefTracer:info(Table) div TraceCount),
+                      "\n"]
                 end || Table <- [input, output, filter] ]
          ]],
     io:put_chars(Status).
@@ -441,12 +441,12 @@ get_sink_handler_status(Sink, Handler, Level) ->
 
 %% @doc Set the loglevel for a particular backend.
 set_loglevel(Handler, Level) when is_atom(Level) ->
-    set_loglevel(?DEFAULT_SINK, Handler, undefined, Level).
+   set_loglevel(?RumDefSink, Handler, undefined, Level).
 
 %% @doc Set the loglevel for a particular backend that has multiple identifiers
 %% (eg. the file backend).
 set_loglevel(Handler, Ident, Level) when is_atom(Level) ->
-    set_loglevel(?DEFAULT_SINK, Handler, Ident, Level).
+   set_loglevel(?RumDefSink, Handler, Ident, Level).
 
 %% @doc Set the loglevel for a particular sink's backend that potentially has
 %% multiple identifiers. (Use `undefined' if it doesn't have any.)
@@ -463,31 +463,31 @@ set_loglevel(Sink, Handler, Ident, Level) when is_atom(Level) ->
 %% @doc Get the loglevel for a particular backend on the default sink. In the case that the backend
 %% has multiple identifiers, the lowest is returned.
 get_loglevel(Handler) ->
-    get_loglevel(?DEFAULT_SINK, Handler).
+   get_loglevel(?RumDefSink, Handler).
 
 %% @doc Get the loglevel for a particular sink's backend. In the case that the backend
 %% has multiple identifiers, the lowest is returned.
 get_loglevel(Sink, Handler) ->
     case gen_event:call(Sink, Handler, get_loglevel, infinity) of
         {mask, Mask} ->
-            case lager_util:mask_to_levels(Mask) of
+            case rumUtil:mask_to_levels(Mask) of
                 [] -> none;
                 Levels -> hd(Levels)
             end;
         X when is_integer(X) ->
-            lager_util:num_to_level(X);
+            rumUtil:num_to_level(X);
         Y -> Y
     end.
 
 %% @doc Try to convert an atom to a posix error, but fall back on printing the
 %% term if its not a valid posix error code.
 posix_error(Error) when is_atom(Error) ->
-    case erl_posix_msg:message(Error) of
-        "unknown POSIX error" -> atom_to_list(Error);
-        Message -> Message
-    end;
+   case erl_posix_msg:message(Error) of
+      "unknown POSIX error" -> atom_to_list(Error);
+      Message -> Message
+   end;
 posix_error(Error) ->
-    safe_format_chop("~p", [Error], ?DEFAULT_TRUNCATION).
+   safe_format_chop("~p", [Error], ?RumDefTruncation).
 
 %% @private
 get_loglevels(Sink) ->
@@ -496,7 +496,7 @@ get_loglevels(Sink) ->
 
 %% @doc Set the loghwm for the default sink.
 set_loghwm(Handler, Hwm) when is_integer(Hwm) ->
-    set_loghwm(?DEFAULT_SINK, Handler, Hwm).
+   set_loghwm(?RumDefSink, Handler, Hwm).
 
 %% @doc Set the loghwm for a particular backend.
 set_loghwm(Sink, Handler, Hwm) when is_integer(Hwm) ->
@@ -512,7 +512,7 @@ add_trace_to_loglevel_config(Trace, Sink) ->
     case lists:member(Trace, Traces) of
         false ->
             NewTraces = [Trace|Traces],
-            _ = lager_util:trace_filter([ element(1, T) || T <- NewTraces]),
+            _ = rumUtil:trace_filter([ element(1, T) || T <- NewTraces]),
             lager_config:set({Sink, loglevel}, {MinLevel, [Trace|Traces]});
         _ ->
             ok
@@ -533,7 +533,7 @@ minimum_loglevel(Levels) ->
     lists:foldl(fun({mask, Mask}, Acc) ->
                 Mask bor Acc;
             (Level, Acc) when is_integer(Level) ->
-                {mask, Mask} = lager_util:config_to_mask(lager_util:num_to_level(Level)),
+                {mask, Mask} = rumUtil:config_to_mask(rumUtil:num_to_level(Level)),
                 Mask bor Acc;
             (_, Acc) ->
                 Acc
@@ -740,7 +740,7 @@ get_sink_handler_status_unicode_test() ->
     validate_status(File).
 
 validate_status(File) ->
-    Handler = {lager_file_backend, File},
-    Status = get_sink_handler_status(?DEFAULT_SINK, Handler, debug),
-    ?assertNotEqual(nomatch, string:find(Status, File)).
+   Handler = {lager_file_backend, File},
+   Status = get_sink_handler_status(?RumDefSink, Handler, debug),
+   ?assertNotEqual(nomatch, string:find(Status, File)).
 -endif.

src/lager_app.erl

@@ -1,426 +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 Lager's application module. Not a lot to see here.
-
-%% @private
-
--module(lager_app).
-
--behaviour(application).
--include("lager.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]).
-
-%% The `application:get_env/3` compatibility wrapper was useful
-%% for other modules in r15 and before
--export([get_env/3]).
-
--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}]
-         }
-        ]).
-
-start() ->
-    application:start(lager).
-
-start_throttle(Sink, Threshold, Window) ->
-    _ = supervisor:start_child(lager_handler_watcher_sup,
-                               [Sink, ?THROTTLE, [Threshold, Window]]),
-    ok.
-
-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]),
-    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]),
-    throw({error, bad_config});
-determine_async_behavior(Sink, Threshold, Window) ->
-    start_throttle(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]),
-    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,
-                                      expand_handlers(Handlers))),
-    ok.
-
-start_handler(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,
-    case ordsets:is_element(F, Fs) of
-        true ->
-            error_logger:error_msg(
-              "Cannot have same file (~p) in multiple file backends~n", [F]),
-            throw({error, bad_config});
-        false ->
-            put(?FILENAMES,
-                ordsets:add_element(F, Fs))
-    end,
-    ok;
-check_handler_config(_Handler, Config) when is_list(Config) orelse is_atom(Config) ->
-    ok;
-check_handler_config(Handler, _BadConfig) ->
-    throw({error, {bad_config, Handler}}).
-
-clean_up_config_checks() ->
-    erase(?FILENAMES).
-
-interpret_hwm(undefined) ->
-    undefined;
-interpret_hwm(HWM) when not is_integer(HWM) orelse HWM < 0 ->
-    _ = lager:log(warning, self(), "Invalid error_logger high water mark: ~p, disabling", [HWM]),
-    undefined;
-interpret_hwm(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 ->
-    _ = supervisor:start_child(lager_handler_watcher_sup, [Sink, lager_manager_killer,
-                                                           [HWM, ReinstallTimer]]);
-maybe_install_sink_killer(_Sink, HWM, ReinstallTimer) ->
-    error_logger:error_msg("Invalid value for 'killer_hwm': ~p or 'killer_reinstall_after': ~p", [HWM, ReinstallTimer]),
-    throw({error, bad_config}).
-
--spec start_error_logger_handler(boolean(), pos_integer(), list()) -> list().
-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,
-
-    case whereis(error_logger) of
-        undefined ->
-            %% On OTP 21 and above, error_logger is deprecated in favor of 'logger'
-            %% As a band-aid, boot up error_logger anyway and install it as a logger handler
-            %% we can't use error_logger:add_report_handler because we want supervision of the handler
-            %% so we have to manually add the logger handler
-            %%
-            %% Longer term we should be installing a logger handler instead, but this will bridge the gap
-            %% for now.
-            _ = error_logger:start(),
-            _ = logger:add_handler(error_logger,error_logger,#{level=>info,filter_default=>log}),
-            ok = maybe_remove_logger_handler();
-        _ ->
-            ok
-    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.
-
-%% On OTP 21.1 and higher we need to remove the `default' handler.
-%% But it might not exist, so we will wrap this in a try-catch
-%% block
-maybe_remove_logger_handler() ->
-    try
-        ok = logger:remove_handler(default)
-    catch
-        error:undef -> ok;
-        Err:Reason ->
-            error_logger:error_msg("calling logger:remove_handler(default) failed: ~p ~p",
-                                   [Err, Reason])
-    end.
-
-configure_sink(Sink, SinkDef) ->
-    lager_config:new_sink(Sink),
-    ChildId = lager_util:make_internal_sink_name(Sink),
-    _ = supervisor:start_child(lager_sup,
-                               {ChildId,
-                                {gen_event, start_link,
-                                 [{local, Sink}]},
-                                permanent, 5000, worker, dynamic}),
-    determine_async_behavior(Sink, proplists:get_value(async_threshold, SinkDef),
-                             proplists:get_value(async_threshold_window, SinkDef)
-                            ),
-    _ = maybe_install_sink_killer(Sink, proplists:get_value(killer_hwm, SinkDef),
-                              proplists:get_value(killer_reinstall_after, SinkDef)),
-    start_handlers(Sink,
-                   proplists:get_value(handlers, SinkDef, [])),
-
-    lager:update_loglevel_config(Sink).
-
-
-configure_extra_sinks(Sinks) ->
-    lists:foreach(fun({Sink, Proplist}) -> configure_sink(Sink, Proplist) end,
-                  Sinks).
-
--spec get_env(atom(), atom(), term()) -> term().
-get_env(Application, Key, Default) ->
-    application:get_env(Application, Key, Default).
-
-start(_StartType, _StartArgs) ->
-    {ok, Pid} = lager_sup:start_link(),
-    SavedHandlers = boot(),
-    _ = boot('__all_extra'),
-    _ = boot('__traces'),
-    clean_up_config_checks(),
-    {ok, Pid, SavedHandlers}.
-
-boot() ->
-    %% Handle the default sink.
-    determine_async_behavior(?DEFAULT_SINK,
-                             application:get_env(lager, async_threshold, undefined),
-                             application:get_env(lager, async_threshold_window, undefined)),
-
-    _ = maybe_install_sink_killer(?DEFAULT_SINK, application:get_env(lager, killer_hwm, undefined),
-                                  application:get_env(lager, killer_reinstall_after, undefined)),
-
-    start_handlers(?DEFAULT_SINK,
-                   application:get_env(lager, handlers, ?DEFAULT_HANDLER_CONF)),
-
-    lager:update_loglevel_config(?DEFAULT_SINK),
-
-    SavedHandlers = start_error_logger_handler(
-                      application:get_env(lager, error_logger_redirect, true),
-                      interpret_hwm(application:get_env(lager, error_logger_hwm, 0)),
-                      application:get_env(lager, error_logger_whitelist, [])
-                     ),
-
-    SavedHandlers.
-
-boot('__traces') ->
-    _ = lager_util:trace_filter(none),
-    ok = add_configured_traces();
-
-boot('__all_extra') ->
-    configure_extra_sinks(application:get_env(lager, extra_sinks, []));
-
-boot(?DEFAULT_SINK) -> boot();
-boot(Sink) ->
-    AllSinksDef = application:get_env(lager, extra_sinks, []),
-    boot_sink(Sink, lists:keyfind(Sink, 1, AllSinksDef)).
-
-boot_sink(Sink, {Sink, Def}) ->
-    configure_sink(Sink, Def);
-boot_sink(Sink, false) ->
-    configure_sink(Sink, []).
-
-stop(Handlers) ->
-    lists:foreach(fun(Handler) ->
-          error_logger:add_report_handler(Handler)
-      end, Handlers),
-    lager_config:cleanup().
-
-expand_handlers([]) ->
-    [];
-expand_handlers([{lager_file_backend, [{Key, _Value}|_]=Config}|T]) when is_atom(Key) ->
-    %% this is definitely a new-style config, no expansion needed
-    [maybe_make_handler_id(lager_file_backend, Config) | expand_handlers(T)];
-expand_handlers([{lager_file_backend, Configs}|T]) ->
-    ?INT_LOG(notice, "Deprecated lager_file_backend config detected, please consider updating it", []),
-    [ {lager_file_backend:config_to_id(Config), Config} || Config <- Configs] ++
-      expand_handlers(T);
-expand_handlers([{Mod, Config}|T]) when is_atom(Mod) ->
-    [maybe_make_handler_id(Mod, Config) | expand_handlers(T)];
-expand_handlers([H|T]) ->
-    [H | expand_handlers(T)].
-
-add_configured_traces() ->
-    Traces = case application:get_env(lager, traces) of
-        undefined ->
-            [];
-        {ok, TraceVal} ->
-            TraceVal
-    end,
-
-    lists:foreach(fun start_configured_trace/1, Traces),
-    ok.
-
-start_configured_trace({Handler, Filter}) ->
-    {ok, _} = lager:trace(Handler, Filter);
-start_configured_trace({Handler, Filter, Level}) when is_atom(Level) ->
-    {ok, _} = lager:trace(Handler, Filter, Level).
-
-maybe_make_handler_id(Mod, Config) ->
-    %% Allow the backend to generate a gen_event handler id, if it wants to.
-    %% We don't use erlang:function_exported here because that requires the module
-    %% already be loaded, which is unlikely at this phase of startup. Using code:load
-    %% caused undesirable side-effects with generating code-coverage reports.
-    try Mod:config_to_id(Config) of
-        Id ->
-            {Id, 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.

src/lager_backend_throttle.erl

@@ -22,7 +22,7 @@
 
 -module(lager_backend_throttle).
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -behaviour(gen_event).
 

src/lager_common_test_backend.erl

@@ -19,7 +19,7 @@
                 format_config :: any(),
                 log = [] :: list()}).
 
--include("lager.hrl").
+-include("rum.hrl").
 -define(TERSE_FORMAT,[time, " ", color, "[", severity,"] ", message]).
 
 %% @doc Before every test, just
@@ -59,9 +59,9 @@ init([Level, true]) -> % for backwards compatibility
 init([Level,false]) -> % for backwards compatibility
     init([Level,{lager_default_formatter,?TERSE_FORMAT ++ ["\n"]}]);
 init([Level,{Formatter,FormatterConfig}]) when is_atom(Formatter) ->
-    case lists:member(Level, ?LEVELS) of
+    case lists:member(Level, ?RumLevels) of
         true ->
-            {ok, #state{level=lager_util:config_to_mask(Level),
+            {ok, #state{level= rumUtil:config_to_mask(Level),
                     formatter=Formatter,
                     format_config=FormatterConfig}};
         _ ->
@@ -74,7 +74,7 @@ init(Level) ->
 %% @private
 handle_event({log, Message},
     #state{level=L,formatter=Formatter,format_config=FormatConfig,log=Logs} = State) ->
-    case lager_util:is_loggable(Message,L,?MODULE) of
+    case rumUtil:is_loggable(Message,L,?MODULE) of
         true ->
             Log = Formatter:format(Message,FormatConfig),
             ct:pal(Log),
@@ -92,9 +92,9 @@ handle_event(Event, State) ->
 handle_call(get_loglevel, #state{level=Level} = State) ->
     {ok, Level, State};
 handle_call({set_loglevel, Level}, State) ->
-    case lists:member(Level, ?LEVELS) of
+    case lists:member(Level, ?RumLevels) of
         true ->
-            {ok, ok, State#state{level=lager_util:config_to_mask(Level)}};
+            {ok, ok, State#state{level= rumUtil:config_to_mask(Level)}};
         _ ->
             {ok, {error, bad_log_level}, State}
     end;

src/lager_config.erl

@@ -18,7 +18,7 @@
 
 -module(lager_config).
 
--include("lager.hrl").
+-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]).
@@ -33,7 +33,7 @@
 
 new() ->
     init(),
-    new_sink(?DEFAULT_SINK),
+    new_sink(?RumDefSink),
     %% Need to be able to find the `lager_handler_watcher' for all handlers
     insert_new({?GLOBAL, handlers}, []),
     ok.
@@ -42,7 +42,7 @@ 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, lager_util:config_to_mask(debug)), []}).
+    insert_new({Sink, loglevel}, {element(2, rumUtil:config_to_mask(debug)), []}).
 
 global_get(Key) ->
     global_get(Key, undefined).
@@ -54,20 +54,20 @@ global_set(Key, Value) ->
     set({?GLOBAL, Key}, Value).
 
 
-get({_Sink, _Key}=FullKey) ->
+get({_Sink, _Key} = FullKey) ->
     get(FullKey, undefined);
 get(Key) ->
-    get({?DEFAULT_SINK, Key}, undefined).
+    get({?RumDefSink, Key}, undefined).
 
 get({Sink, Key}, Default) ->
     lookup({Sink, Key}, Default);
 get(Key, Default) ->
-    get({?DEFAULT_SINK, Key}, Default).
+    get({?RumDefSink, Key}, Default).
 
 set({Sink, Key}, Value) ->
     insert({Sink, Key}, Value);
 set(Key, Value) ->
-    set({?DEFAULT_SINK, 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

src/lager_console_backend.erl

@@ -46,7 +46,7 @@
 -endif.
 
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -define(TERSE_FORMAT,[time, " ", color, "[", severity,"] ", message]).
 -define(DEFAULT_FORMAT_CONFIG, ?TERSE_FORMAT ++ [eol()]).
@@ -80,7 +80,7 @@ init(Options) when is_list(Options) ->
     end,
 
     Level = get_option(level, Options, undefined),
-    try {is_new_style_console_available(), lager_util:config_to_mask(Level)} of
+    try {is_new_style_console_available(), rumUtil:config_to_mask(Level)} of
         {false, _} ->
             Msg = "Lager's console backend is incompatible with the 'old' shell, not enabling it",
             %% be as noisy as possible, log to every possible place
@@ -130,7 +130,7 @@ init(Other) ->
 
 validate_options([]) -> true;
 validate_options([{level, L}|T]) when is_atom(L) ->
-    case lists:member(L, ?LEVELS) of
+    case lists:member(L, ?RumLevels) of
         false ->
             throw({error, {fatal, {bad_level, L}}});
         true ->
@@ -161,7 +161,7 @@ get_option(K, Options, Default) ->
 handle_call(get_loglevel, #state{level=Level} = State) ->
     {ok, Level, State};
 handle_call({set_loglevel, Level}, State) ->
-    try lager_util:config_to_mask(Level) of
+    try rumUtil:config_to_mask(Level) of
         Levels ->
             {ok, ok, State#state{level=Levels}}
     catch
@@ -174,7 +174,7 @@ handle_call(_Request, State) ->
 %% @private
 handle_event({log, Message},
     #state{level=L,out=Out,formatter=Formatter,format_config=FormatConfig,colors=Colors,id=ID} = State) ->
-    case lager_util:is_loggable(Message, L, ID) of
+    case rumUtil:is_loggable(Message, L, ID) of
         true ->
             io:put_chars(Out, Formatter:format(Message,FormatConfig,Colors)),
             {ok, State};
@@ -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, lager_util:config_to_mask(info)), []}),
+                        lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                         lager: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, lager_util:config_to_mask(info)), []}),
+                        lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                         lager:info("Test message"),
                         PidStr = pid_to_list(self()),
                         receive
@@ -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, lager_util:config_to_mask(info)), []}),
+                        lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                         lager: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, lager_util:config_to_mask(info)), []}),
+                        lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                         erlang:group_leader(Pid, whereis(lager_event)),
                         lager: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, lager_util:config_to_mask(info)), []}),
+                        lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                         lager:set_loglevel(lager_console_backend, '!=info'),
                         erlang:group_leader(Pid, whereis(lager_event)),
                         lager: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, lager_util:config_to_mask(info)), []}),
+                        lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                         lager:set_loglevel(lager_console_backend, '=debug'),
                         erlang:group_leader(Pid, whereis(lager_event)),
                         lager: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, lager_util:config_to_mask(info)), []}),
+                        lager_config:set({lager_event, loglevel}, {element(2, rumUtil:config_to_mask(info)), []}),
                         lager:info("Test message"),
                         ?assertNotEqual({group_leader, Pid}, erlang:process_info(whereis(lager_event), group_leader)),
                         receive

src/lager_crash_log.erl

@@ -33,7 +33,7 @@
 
 -module(lager_crash_log).
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -behaviour(gen_server).
 
@@ -73,7 +73,7 @@ start(Filename, MaxBytes, Size, Date, Count, Rotator) ->
 
 %% @private
 init([RelFilename, MaxBytes, Size, Date, Count, Rotator]) ->
-    Filename = lager_util:expand_path(RelFilename),
+    Filename = rumUtil:expand_path(RelFilename),
     case Rotator:open_logfile(Filename, false) of
         {ok, {FD, Inode, Ctime, _Size}} ->
             schedule_rotation(Date),
@@ -120,7 +120,7 @@ code_change(_OldVsn, State, _Extra) ->
 schedule_rotation(undefined) ->
     ok;
 schedule_rotation(Date) ->
-    erlang:send_after(lager_util:calculate_next_rotation(Date) * 1000, self(), rotate),
+    erlang:send_after(rumUtil:calculate_next_rotation(Date) * 1000, self(), rotate),
     ok.
 
 %% ===== Begin code lifted from riak_err =====
@@ -210,7 +210,7 @@ do_log({log, Event}, #state{name=Name, fd=FD, inode=Inode, ctime=Ctime, flap=Fla
                     _ = Rotator:rotate_logfile(Name, Count),
                     handle_cast({log, Event}, State);
                 {ok, {NewFD, NewInode, NewCtime, _Size}} ->
-                    {Date, TS} = lager_util:format_time(
+                    {Date, TS} = rumUtil:format_time(
                         lager_stdlib:maybe_utc(erlang:localtime())),
                     Time = [Date, " ", TS," =", ReportStr, "====\n"],
                     NodeSuffix = other_node_suffix(Pid),
@@ -243,11 +243,11 @@ do_log({log, Event}, #state{name=Name, fd=FD, inode=Inode, ctime=Ctime, flap=Fla
 filesystem_test_() ->
     {foreach,
         fun() ->
-            {ok, TestDir} = lager_util:create_test_dir(),
+            {ok, TestDir} = rumUtil:create_test_dir(),
             CrashLog = filename:join(TestDir, "crash_test.log"),
-            ok = lager_util:safe_write_file(CrashLog, []),
+            ok = rumUtil:safe_write_file(CrashLog, []),
             ok = error_logger:tty(false),
-            ok = lager_util:safe_application_load(lager),
+            ok = rumUtil:safe_application_load(lager),
             ok = application:set_env(lager, handlers, [{lager_test_backend, info}]),
             ok = application:set_env(lager, error_logger_redirect, true),
             ok = application:unset_env(lager, crash_log),
@@ -265,7 +265,7 @@ filesystem_test_() ->
             end,
             ok = application:stop(lager),
             ok = application:stop(goldrush),
-            ok = lager_util:delete_test_dir(),
+            ok = rumUtil:delete_test_dir(),
             ok = error_logger:tty(true)
         end, [
         fun(CrashLog) ->
@@ -310,7 +310,7 @@ filesystem_test_() ->
                         _ = gen_event:which_handlers(error_logger),
                         ?assertEqual(1, lager_test_backend:count()),
                         ?assertEqual(ok, file:delete(CrashLog)),
-                        ?assertEqual(ok, lager_util:safe_write_file(CrashLog, "")),
+                        ?assertEqual(ok, rumUtil:safe_write_file(CrashLog, "")),
                         {ok, FInfo0} = file:read_file_info(CrashLog, [raw]),
                         FInfo1 = FInfo0#file_info{mode = 0},
                         ?assertEqual(ok, file:write_file_info(CrashLog, FInfo1)),
@@ -363,7 +363,7 @@ filesystem_test_() ->
                         {ok, Bin} = file:read_file(CrashLog),
                         ?assertMatch([_, "Test message\n"], re:split(Bin, "\n", [{return, list}, {parts, 2}])),
                         ?assertEqual(ok, file:delete(CrashLog)),
-                        ?assertEqual(ok, lager_util:safe_write_file(CrashLog, "")),
+                        ?assertEqual(ok, rumUtil:safe_write_file(CrashLog, "")),
                         sync_error_logger:error_msg("Test message1~n"),
                         _ = gen_event:which_handlers(error_logger),
                         {ok, Bin1} = file:read_file(CrashLog),

src/lager_default_formatter.erl

@@ -19,7 +19,7 @@
 %%
 %% Include files
 %%
--include("lager.hrl").
+-include("rum.hrl").
 -ifdef(TEST).
 -include_lib("eunit/include/eunit.hrl").
 -endif.
@@ -92,7 +92,7 @@ output({blank,Fill},_Msg) ->
     Fill;
 output(sev,Msg) ->
     %% Write brief acronym for the severity level (e.g. debug -> $D)
-    [lager_util:level_to_chr(lager_msg:severity(Msg))];
+    [rumUtil:level_to_chr(lager_msg:severity(Msg))];
 output(metadata, Msg) ->
     output({metadata, "=", " "}, Msg);
 output({metadata, IntSep, FieldSep}, Msg) ->
@@ -139,7 +139,7 @@ output(severity, Msg, Width) ->
     make_printable(atom_to_list(lager_msg:severity(Msg)), Width);
 output(sev,Msg, _Width) ->
     %% Write brief acronym for the severity level (e.g. debug -> $D)
-    [lager_util:level_to_chr(lager_msg:severity(Msg))];
+    [rumUtil:level_to_chr(lager_msg:severity(Msg))];
 output(node, Msg, _Width) ->
     output({node, atom_to_list(node())}, Msg, _Width);
 output(blank,_Msg, _Width) ->
@@ -208,8 +208,6 @@ maybe_get_persistent_term(_Key, Default) -> Default.
 -endif.
 
 run_function(Function, Default) ->
-   eRum = 1,
-   ERum = 2,
     try Function() of
         Result ->
             Result
@@ -270,7 +268,7 @@ uppercase_severity(emergency) -> "EMERGENCY".
 -ifdef(TEST).
 date_time_now() ->
     Now = os:timestamp(),
-    {Date, Time} = lager_util:format_time(lager_util:maybe_utc(lager_util:localtime_ms(Now))),
+    {Date, Time} = rumUtil:format_time(rumUtil:maybe_utc(rumUtil:localtime_ms(Now))),
     {Date, Time, Now}.
 
 basic_test_() ->

src/lager_file_backend.erl

@@ -34,7 +34,7 @@
 
 -module(lager_file_backend).
 
--include("lager.hrl").
+-include("rum.hrl").
 -include_lib("kernel/include/file.hrl").
 
 -behaviour(gen_event).
@@ -70,7 +70,7 @@
         date :: undefined | string(),
         count = 10 :: integer(),
         rotator = lager_util :: atom(),
-        shaper :: lager_shaper(),
+        shaper :: rumShaper(),
         formatter :: atom(),
         formatter_config :: any(),
         sync_on :: {'mask', integer()},
@@ -118,9 +118,9 @@ init(LogFileConfig) when is_list(LogFileConfig) ->
             [RelName, Level, Date, Size, Count, Rotator, HighWaterMark, Flush, SyncInterval, SyncSize, SyncOn, CheckInterval, Formatter, FormatterConfig] =
               [proplists:get_value(Key, Config) || Key <- [file, level, date, size, count, rotator, high_water_mark, flush_queue, sync_interval, sync_size, sync_on, check_interval, formatter, formatter_config]],
             FlushThr = proplists:get_value(flush_threshold, Config, 0),
-            Name = lager_util:expand_path(RelName),
+            Name = rumUtil:expand_path(RelName),
             schedule_rotation(Name, Date),
-            Shaper = lager_util:maybe_flush(Flush, #lager_shaper{hwm=HighWaterMark, flush_threshold = FlushThr, id=Name}),
+            Shaper = rumUtil:maybe_flush(Flush, #rumShaper{hwm=HighWaterMark, flushThreshold = FlushThr, id=Name}),
             State0 = #state{name=Name, level=Level, size=Size, date=Date, count=Count, rotator=Rotator,
                 shaper=Shaper, formatter=Formatter, formatter_config=FormatterConfig,
                 sync_on=SyncOn, sync_interval=SyncInterval, sync_size=SyncSize, check_interval=CheckInterval},
@@ -150,9 +150,9 @@ handle_call({set_loghwm, Hwm}, #state{shaper=Shaper, name=Name} = State) ->
         false ->
             {ok, {error, bad_log_hwm}, State};
         _ ->
-            NewShaper = Shaper#lager_shaper{hwm=Hwm},
+            NewShaper = Shaper#rumShaper{hwm=Hwm},
             ?INT_LOG(notice, "Changed loghwm of ~ts to ~p", [Name, Hwm]),
-            {ok, {last_loghwm, Shaper#lager_shaper.hwm}, State#state{shaper=NewShaper}}
+            {ok, {last_loghwm, Shaper#rumShaper.hwm}, State#state{shaper=NewShaper}}
     end;
 handle_call(rotate, State = #state{name=File}) ->
     {ok, NewState} = handle_info({rotate, File}, State),
@@ -163,10 +163,10 @@ handle_call(_Request, State) ->
 %% @private
 handle_event({log, Message},
     #state{name=Name, level=L, shaper=Shaper, formatter=Formatter,formatter_config=FormatConfig} = State) ->
-    case lager_util:is_loggable(Message,L,{lager_file_backend, Name}) of
+    case rumUtil:is_loggable(Message,L,{lager_file_backend, Name}) of
         true ->
-            case lager_util:check_hwm(Shaper) of
-                {true, Drop, #lager_shaper{hwm=Hwm} = NewShaper} ->
+            case rumUtil:check_hwm(Shaper) of
+                {true, Drop, #rumShaper{hwm=Hwm} = NewShaper} ->
                     NewState = case Drop > 0 of
                         true ->
                             Report = io_lib:format(
@@ -181,8 +181,8 @@ handle_event({log, Message},
                     {ok,write(NewState#state{shaper=NewShaper},
                         lager_msg:timestamp(Message), lager_msg:severity_as_int(Message),
                         Formatter:format(Message,FormatConfig))};
-                {false, _, #lager_shaper{dropped=D} = NewShaper} ->
-                    {ok, State#state{shaper=NewShaper#lager_shaper{dropped=D+1}}}
+                {false, _, #rumShaper{dropped=D} = NewShaper} ->
+                    {ok, State#state{shaper=NewShaper#rumShaper{dropped=D+1}}}
             end;
         false ->
             {ok, State}
@@ -197,18 +197,18 @@ handle_info({rotate, File}, #state{name=File, count=Count, date=Date, rotator=Ro
     schedule_rotation(File, Date),
     {ok, State1};
 handle_info({shaper_expired, Name}, #state{shaper=Shaper, name=Name, formatter=Formatter, formatter_config=FormatConfig} = State) ->
-    _ = case Shaper#lager_shaper.dropped of
+    _ = case Shaper#rumShaper.dropped of
             0 ->
                 ok;
             Dropped ->
                 Report = io_lib:format(
                            "lager_file_backend dropped ~p messages in the last second that exceeded the limit of ~p messages/sec",
-                           [Dropped, Shaper#lager_shaper.hwm]),
+                           [Dropped, Shaper#rumShaper.hwm]),
                 ReportMsg = lager_msg:new(Report, warning, [], []),
                 write(State, lager_msg:timestamp(ReportMsg),
                       lager_msg:severity_as_int(ReportMsg), Formatter:format(ReportMsg, FormatConfig))
         end,
-    {ok, State#state{shaper=Shaper#lager_shaper{dropped=0, mps=0, lasttime=os:timestamp()}}};
+    {ok, State#state{shaper=Shaper#rumShaper{dropped=0, mps=0, lastTime =os:timestamp()}}};
 handle_info(_Info, State) ->
     {ok, State}.
 
@@ -291,7 +291,7 @@ write_should_check(#state{last_check=LastCheck0, check_interval=CheckInterval,
         _ ->
             % We need to know if the file has changed "out from under lager" so we don't
             % write to an invalid FD
-            {Result, _FInfo} = lager_util:has_file_changed(Name, Inode0, Ctime0),
+            {Result, _FInfo} = rumUtil:has_file_changed(Name, Inode0, Ctime0),
             Result
     end.
 
@@ -318,7 +318,7 @@ do_write(#state{fd=FD, name=Name, flap=Flap} = State, Level, Msg) ->
     end.
 
 validate_loglevel(Level) ->
-    try lager_util:config_to_mask(Level) of
+    try rumUtil:config_to_mask(Level) of
         Levels ->
             Levels
     catch
@@ -335,7 +335,7 @@ validate_logfile_proplist(List) ->
                     false;
                 _File ->
                     %% merge with the default options
-                    {ok, DefaultRotationDate} = lager_util:parse_rotation_date_spec(?DEFAULT_ROTATION_DATE),
+                    {ok, DefaultRotationDate} = rumUtil:parse_rotation_date_spec(?DEFAULT_ROTATION_DATE),
                     lists:keymerge(1, lists:sort(Res), lists:sort([
                             {level, validate_loglevel(?DEFAULT_LOG_LEVEL)}, {date, DefaultRotationDate},
                             {size, ?DEFAULT_ROTATION_SIZE}, {count, ?DEFAULT_ROTATION_COUNT},
@@ -393,7 +393,7 @@ validate_logfile_proplist([{high_water_mark, HighWaterMark}|Tail], Acc) ->
             throw({bad_config, "Invalid high water mark", HighWaterMark})
     end;
 validate_logfile_proplist([{date, Date}|Tail], Acc) ->
-    case lager_util:parse_rotation_date_spec(Date) of
+    case rumUtil:parse_rotation_date_spec(Date) of
         {ok, Spec} ->
             validate_logfile_proplist(Tail, [{date, Spec}|Acc]);
         {error, _} when Date == "" ->
@@ -466,7 +466,7 @@ validate_logfile_proplist([Other|_Tail], _Acc) ->
 schedule_rotation(_, undefined) ->
     ok;
 schedule_rotation(Name, Date) ->
-    erlang:send_after(lager_util:calculate_next_rotation(Date) * 1000, self(), {rotate, Name}),
+    erlang:send_after(rumUtil:calculate_next_rotation(Date) * 1000, self(), {rotate, Name}),
     ok.
 
 close_file(#state{fd=undefined} = State) ->
@@ -483,11 +483,11 @@ close_file(#state{fd=FD} = State) ->
 
 get_loglevel_test() ->
     {ok, Level, _} = handle_call(get_loglevel,
-        #state{name="bar", level=lager_util:config_to_mask(info), fd=0, inode=0, ctime=undefined}),
-    ?assertEqual(Level, lager_util:config_to_mask(info)),
+        #state{name="bar", level= rumUtil:config_to_mask(info), fd=0, inode=0, ctime=undefined}),
+    ?assertEqual(Level, rumUtil:config_to_mask(info)),
     {ok, Level2, _} = handle_call(get_loglevel,
-        #state{name="foo", level=lager_util:config_to_mask(warning), fd=0, inode=0, ctime=undefined}),
-    ?assertEqual(Level2, lager_util:config_to_mask(warning)).
+        #state{name="foo", level= rumUtil:config_to_mask(warning), fd=0, inode=0, ctime=undefined}),
+    ?assertEqual(Level2, rumUtil:config_to_mask(warning)).
 
 rotation_test_() ->
     {foreach,
@@ -497,7 +497,7 @@ rotation_test_() ->
             SyncInterval = ?DEFAULT_SYNC_INTERVAL,
             Rotator = ?DEFAULT_ROTATION_MOD,
             CheckInterval = 0, %% hard to test delayed mode
-            {ok, TestDir} = lager_util:create_test_dir(),
+            {ok, TestDir} = rumUtil:create_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
             {OsType, _} = os:type(),
             #state{name=TestLog,
@@ -510,7 +510,7 @@ rotation_test_() ->
                    os_type=OsType}
         end,
         fun(#state{}) ->
-            ok = lager_util:delete_test_dir()
+            ok = rumUtil:delete_test_dir()
         end, [
         fun(DefaultState=#state{name=TestLog, os_type=OsType, sync_size=SyncSize, sync_interval=SyncInterval, rotator=Rotator}) ->
             {"External rotation should work",
@@ -608,11 +608,11 @@ filesystem_test_() ->
     {foreach,
         fun() ->
             ok = error_logger:tty(false),
-            ok = lager_util:safe_application_load(lager),
+            ok = rumUtil:safe_application_load(lager),
             ok = application:set_env(lager, handlers, [{lager_test_backend, info}]),
             ok = application:set_env(lager, error_logger_redirect, false),
             ok = application:set_env(lager, async_threshold, undefined),
-            {ok, _TestDir} = lager_util:create_test_dir(),
+            {ok, _TestDir} = rumUtil:create_test_dir(),
             ok = lager:start(),
             %% race condition where lager logs its own start up
             %% makes several tests fail. See test/lager_test_backend
@@ -624,11 +624,11 @@ filesystem_test_() ->
             ok = application:stop(lager),
             ok = application:stop(goldrush),
             ok = error_logger:tty(true),
-            ok = lager_util:delete_test_dir()
+            ok = rumUtil:delete_test_dir()
         end, [
         {"under normal circumstances, file should be opened",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
             gen_event:add_handler(lager_event, lager_file_backend,
@@ -641,7 +641,7 @@ filesystem_test_() ->
         end},
         {"don't choke on unicode",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
             gen_event:add_handler(lager_event, lager_file_backend,
@@ -655,7 +655,7 @@ filesystem_test_() ->
         end},
         {"don't choke on latin-1",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
             %% XXX if this test fails, check that this file is encoded latin-1, not utf-8!
@@ -670,9 +670,9 @@ filesystem_test_() ->
         end},
         {"file can't be opened on startup triggers an error message",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
-            ?assertEqual(ok, lager_util:safe_write_file(TestLog, [])),
+            ?assertEqual(ok, rumUtil:safe_write_file(TestLog, [])),
 
             {ok, FInfo0} = file:read_file_info(TestLog, [raw]),
             FInfo1 = FInfo0#file_info{mode = 0},
@@ -700,7 +700,7 @@ filesystem_test_() ->
                     % deleted or renamed while a process has an open file handle referencing it
                     ok;
                 _ ->
-                    {ok, TestDir} = lager_util:get_test_dir(),
+                    {ok, TestDir} = rumUtil:get_test_dir(),
                     TestLog = filename:join(TestDir, "test.log"),
 
                     gen_event:add_handler(lager_event, lager_file_backend,
@@ -709,7 +709,7 @@ filesystem_test_() ->
                     lager:log(error, self(), "Test message"),
                     ?assertEqual(1, lager_test_backend:count()),
                     ?assertEqual(ok, file:delete(TestLog)),
-                    ?assertEqual(ok, lager_util:safe_write_file(TestLog, "")),
+                    ?assertEqual(ok, rumUtil:safe_write_file(TestLog, "")),
                     {ok, FInfo0} = file:read_file_info(TestLog, [raw]),
                     FInfo1 = FInfo0#file_info{mode = 0},
                     ?assertEqual(ok, file:write_file_info(TestLog, FInfo1)),
@@ -724,9 +724,9 @@ filesystem_test_() ->
         end},
         {"unavailable files that are fixed at runtime should start having log messages written",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
-            ?assertEqual(ok, lager_util:safe_write_file(TestLog, [])),
+            ?assertEqual(ok, rumUtil:safe_write_file(TestLog, [])),
 
             {ok, FInfo} = file:read_file_info(TestLog, [raw]),
             OldPerms = FInfo#file_info.mode,
@@ -753,7 +753,7 @@ filesystem_test_() ->
                     % while a process has an open file handle referencing it
                     ok;
                 _ ->
-                    {ok, TestDir} = lager_util:get_test_dir(),
+                    {ok, TestDir} = rumUtil:get_test_dir(),
                     TestLog = filename:join(TestDir, "test.log"),
                     TestLog0 = TestLog ++ ".0",
 
@@ -763,7 +763,7 @@ filesystem_test_() ->
                     lager:log(error, self(), "Test message1"),
                     ?assertEqual(1, lager_test_backend:count()),
                     ?assertEqual(ok, file:delete(TestLog)),
-                    ?assertEqual(ok, lager_util:safe_write_file(TestLog, "")),
+                    ?assertEqual(ok, rumUtil:safe_write_file(TestLog, "")),
                     lager:log(error, self(), "Test message2"),
                     ?assertEqual(2, lager_test_backend:count()),
                     {ok, Bin} = file:read_file(TestLog),
@@ -780,7 +780,7 @@ filesystem_test_() ->
         end},
         {"internal size rotation should work",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
             TestLog0 = TestLog ++ ".0",
 
@@ -792,7 +792,7 @@ filesystem_test_() ->
         end},
         {"internal time rotation should work",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
             TestLog0 = TestLog ++ ".0",
 
@@ -806,7 +806,7 @@ filesystem_test_() ->
         end},
         {"rotation call should work",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
             TestLog0 = TestLog ++ ".0",
 
@@ -820,7 +820,7 @@ filesystem_test_() ->
         end},
         {"sync_on option should work",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
             gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog},
@@ -834,7 +834,7 @@ filesystem_test_() ->
         end},
         {"sync_on none option should work (also tests sync_interval)",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
             gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog},
@@ -850,7 +850,7 @@ filesystem_test_() ->
         end},
         {"sync_size option should work",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
             gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info},
@@ -873,7 +873,7 @@ filesystem_test_() ->
         end},
         {"runtime level changes",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
             gen_event:add_handler(lager_event, {lager_file_backend, TestLog}, {TestLog, info}),
@@ -892,7 +892,7 @@ filesystem_test_() ->
         end},
         {"invalid runtime level changes",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
             TestLog3 = filename:join(TestDir, "test3.log"),
 
@@ -903,7 +903,7 @@ filesystem_test_() ->
         end},
         {"tracing should work",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
 
             gen_event:add_handler(lager_event, lager_file_backend, {TestLog, critical}),
@@ -926,7 +926,7 @@ filesystem_test_() ->
                     % deleted or renamed while a process has an open file handle referencing it
                     ok;
                 _ ->
-                    {ok, TestDir} = lager_util:get_test_dir(),
+                    {ok, TestDir} = rumUtil:get_test_dir(),
                     TestLog = filename:join(TestDir, "test.log"),
 
                     gen_event:add_handler(lager_event, lager_file_backend,
@@ -953,7 +953,7 @@ filesystem_test_() ->
         end},
         {"tracing to a dedicated file should work",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "foo.log"),
 
             {ok, _} = lager:trace_file(TestLog, [{module, ?MODULE}]),
@@ -966,7 +966,7 @@ filesystem_test_() ->
         end},
         {"tracing to a dedicated file should work even if root_log is set",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             LogName = "foo.log",
             LogPath = filename:join(TestDir, LogName),
 
@@ -982,7 +982,7 @@ filesystem_test_() ->
         end},
         {"tracing with options should work",
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "foo.log"),
             TestLog0 = TestLog ++ ".0",
 
@@ -1002,7 +1002,7 @@ filesystem_test_() ->
         {"no silent hwm drops",
         fun() ->
             MsgCount = 15,
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             TestLog = filename:join(TestDir, "test.log"),
             gen_event:add_handler(lager_event, lager_file_backend, [{file, TestLog}, {level, info},
                 {high_water_mark, 5}, {flush_queue, false}, {sync_on, "=warning"}]),
@@ -1023,13 +1023,13 @@ filesystem_test_() ->
 trace_files_test_() ->
     {foreach,
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             Log     = filename:join(TestDir, "test.log"),
             Debug   = filename:join(TestDir, "debug.log"),
             Events  = filename:join(TestDir, "events.log"),
 
             ok = error_logger:tty(false),
-            ok = lager_util:safe_application_load(lager),
+            ok = rumUtil:safe_application_load(lager),
             ok = application:set_env(lager, handlers, [
                      {lager_file_backend, [
                          {file, Log},
@@ -1054,7 +1054,7 @@ trace_files_test_() ->
             catch ets:delete(lager_config),
             ok = application:unset_env(lager, traces),
             ok = application:stop(lager),
-            ok = lager_util:delete_test_dir(),
+            ok = rumUtil:delete_test_dir(),
             ok = error_logger:tty(true)
         end, [
         fun({Log, Debug, Events}) ->
@@ -1097,13 +1097,13 @@ count_lines_until(Lines, Timeout, File, Last) ->
 formatting_test_() ->
     {foreach,
         fun() ->
-            {ok, TestDir} = lager_util:get_test_dir(),
+            {ok, TestDir} = rumUtil:get_test_dir(),
             Log1 = filename:join(TestDir, "test.log"),
             Log2 = filename:join(TestDir, "test2.log"),
-            ?assertEqual(ok, lager_util:safe_write_file(Log1, [])),
-            ?assertEqual(ok, lager_util:safe_write_file(Log2, [])),
+            ?assertEqual(ok, rumUtil:safe_write_file(Log1, [])),
+            ?assertEqual(ok, rumUtil:safe_write_file(Log2, [])),
             ok = error_logger:tty(false),
-            ok = lager_util:safe_application_load(lager),
+            ok = rumUtil:safe_application_load(lager),
             ok = application:set_env(lager, handlers, [{lager_test_backend, info}]),
             ok = application:set_env(lager, error_logger_redirect, false),
             ok = lager:start(),
@@ -1114,7 +1114,7 @@ formatting_test_() ->
         fun({ok, _, _}) ->
             ok = application:stop(lager),
             ok = application:stop(goldrush),
-            ok = lager_util:delete_test_dir(),
+            ok = rumUtil:delete_test_dir(),
             ok = error_logger:tty(true)
         end, [
         fun({ok, Log1, Log2}) ->

src/lager_handler_watcher.erl

@@ -23,7 +23,7 @@
 
 -behaviour(gen_server).
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -ifdef(TEST).
 -include_lib("eunit/include/eunit.hrl").

src/lager_manager_killer.erl

@@ -6,7 +6,7 @@
 
 -export([kill_me/0]).
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -record(state, {
           killer_hwm :: non_neg_integer(),

src/lager_msg.erl

@@ -24,7 +24,7 @@
 %% create with provided timestamp, handy for testing mostly
 -spec new(list(), erlang:timestamp(), lager:log_level(), [tuple()], list()) -> lager_msg().
 new(Msg, Timestamp, Severity, Metadata, Destinations) ->
-    {Date, Time} = lager_util:format_time(lager_util:maybe_utc(lager_util:localtime_ms(Timestamp))),
+    {Date, Time} = rumUtil:format_time(rumUtil:maybe_utc(rumUtil:localtime_ms(Timestamp))),
     #lager_msg{message=Msg, datetime={Date, Time}, timestamp=Timestamp, severity=Severity,
         metadata=Metadata, destinations=Destinations}.
 
@@ -51,7 +51,7 @@ severity(Msg) ->
 
 -spec severity_as_int(lager_msg()) -> lager:log_level_number().
 severity_as_int(Msg) ->
-    lager_util:level_to_num(Msg#lager_msg.severity).
+    rumUtil:level_to_num(Msg#lager_msg.severity).
 
 -spec metadata(lager_msg()) -> [tuple()].
 metadata(Msg) ->

src/lager_rotator_default.erl

@@ -42,7 +42,7 @@ open_logfile(Name, Buffer) ->
 ensure_logfile(Name, undefined, _Inode, _Ctime, Buffer) ->
     open_logfile(Name, Buffer);
 ensure_logfile(Name, FD, Inode0, Ctime0, Buffer) ->
-    case lager_util:has_file_changed(Name, Inode0, Ctime0) of
+    case rumUtil:has_file_changed(Name, Inode0, Ctime0) of
         {true, _FInfo} ->
             reopen_logfile(Name, FD, Buffer);
         {_, FInfo} ->
@@ -113,10 +113,10 @@ do_update_ctime(_, _Name, FInfo) ->
 
 rotate_file_test() ->
     RotCount = 10,
-    {ok, TestDir} = lager_util:create_test_dir(),
+    {ok, TestDir} = rumUtil:create_test_dir(),
     TestLog = filename:join(TestDir, "rotation.log"),
     Outer = fun(N) ->
-        ?assertEqual(ok, lager_util:safe_write_file(TestLog, erlang:integer_to_list(N))),
+        ?assertEqual(ok, rumUtil:safe_write_file(TestLog, erlang:integer_to_list(N))),
         Inner = fun(M) ->
             File = lists:flatten([TestLog, $., erlang:integer_to_list(M)]),
             ?assert(filelib:is_regular(File)),
@@ -133,11 +133,11 @@ rotate_file_test() ->
         rotate_logfile(TestLog, RotCount)
     end,
     lists:foreach(Outer, lists:seq(0, (RotCount * 2))),
-    lager_util:delete_test_dir(TestDir).
+    rumUtil:delete_test_dir(TestDir).
 
 rotate_file_zero_count_test() ->
     %% Test that a rotation count of 0 simply truncates the file
-    {ok, TestDir} = lager_util:create_test_dir(),
+    {ok, TestDir} = rumUtil:create_test_dir(),
     TestLog = filename:join(TestDir, "rotation.log"),
     ?assertMatch(ok, rotate_logfile(TestLog, 0)),
     ?assertNot(filelib:is_regular(TestLog ++ ".0")),
@@ -150,23 +150,23 @@ rotate_file_zero_count_test() ->
         _ ->
             ?assert(false)
     end,
-    lager_util:delete_test_dir(TestDir).
+    rumUtil:delete_test_dir(TestDir).
 
 rotate_file_fail_test() ->
-    {ok, TestDir} = lager_util:create_test_dir(),
+    {ok, TestDir} = rumUtil:create_test_dir(),
     TestLog = filename:join(TestDir, "rotation.log"),
 
     %% set known permissions on it
-    ok = lager_util:set_dir_permissions("u+rwx", TestDir),
+    ok = rumUtil:set_dir_permissions("u+rwx", TestDir),
 
     %% write a file
-    ?assertEqual(ok, lager_util:safe_write_file(TestLog, "hello")),
+    ?assertEqual(ok, rumUtil:safe_write_file(TestLog, "hello")),
 
     case os:type() of
         {win32, _} -> ok;
         _ ->
             %% hose up the permissions
-            ok = lager_util:set_dir_permissions("u-w", TestDir),
+            ok = rumUtil:set_dir_permissions("u-w", TestDir),
             ?assertMatch({error, _}, rotate_logfile(TestLog, 10))
     end,
 
@@ -175,7 +175,7 @@ rotate_file_fail_test() ->
     ?assert(filelib:is_regular(TestLog)),
 
     %% fix the permissions
-    ok = lager_util:set_dir_permissions("u+w", TestDir),
+    ok = rumUtil:set_dir_permissions("u+w", TestDir),
 
     ?assertMatch(ok, rotate_logfile(TestLog, 10)),
     ?assert(filelib:is_regular(TestLog ++ ".0")),
@@ -192,6 +192,6 @@ rotate_file_fail_test() ->
 
     %% check that the .0 file now has the contents "hello"
     ?assertEqual({ok, <<"hello">>}, file:read_file(TestLog++".0")),
-    lager_util:delete_test_dir(TestDir).
+    rumUtil:delete_test_dir(TestDir).
 
 -endif.

src/lager_sup.erl

@@ -1,92 +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 Lager's top level supervisor.
-
-%% @private
-
--module(lager_sup).
-
--behaviour(supervisor).
-
-%% API
--export([start_link/0]).
-
-%% Callbacks
--export([init/1]).
-
-start_link() ->
-    supervisor:start_link({local, ?MODULE}, ?MODULE, []).
-
-init([]) ->
-    %% set up the config, is safe even during relups
-    lager_config: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]}],
-
-    CrashLog = decide_crash_log(application:get_env(lager, crash_log, false)),
-
-    {ok, {{one_for_one, 10, 60},
-          Children ++ CrashLog
-         }}.
-
-validate_positive({ok, Val}, _Default) when is_integer(Val) andalso Val >= 0 ->
-    Val;
-validate_positive(_Val, Default) ->
-    Default.
-
-determine_rotation_date({ok, ""}) ->
-    undefined;
-determine_rotation_date({ok, Val3}) ->
-    case lager_util:parse_rotation_date_spec(Val3) of
-        {ok, Spec} -> Spec;
-        {error, _} ->
-            error_logger:error_msg("Invalid date spec for "
-                                   "crash log ~p~n", [Val3]),
-            undefined
-    end;
-determine_rotation_date(_) ->
-    undefined.
-
-determine_rotator_mod({ok, Mod}, _Default) when is_atom(Mod) ->
-    Mod;
-determine_rotator_mod(_, Default) ->
-    Default.
-
-decide_crash_log(undefined) ->
-    [];
-decide_crash_log(false) ->
-    [];
-decide_crash_log(File) ->
-    MaxBytes = validate_positive(application:get_env(lager, crash_log_msg_size), 65536),
-    RotationSize = validate_positive(application:get_env(lager, crash_log_size), 0),
-    RotationCount = validate_positive(application:get_env(lager, crash_log_count), 0),
-
-    RotationDate = determine_rotation_date(application:get_env(lager, crash_log_date)),
-    RotationMod = determine_rotator_mod(application:get_env(lager, crash_log_rotator), lager_rotator_default),
-
-
-    [{lager_crash_log, {lager_crash_log, start_link, [File, MaxBytes,
-                                                      RotationSize, RotationDate, RotationCount, RotationMod]},
-      permanent, 5000, worker, [lager_crash_log]}].

src/lager_transform.erl

@@ -23,23 +23,23 @@
 
 -module(lager_transform).
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -export([parse_transform/2]).
 
 %% @private
 parse_transform(AST, Options) ->
-    TruncSize = proplists:get_value(lager_truncation_size, Options, ?DEFAULT_TRUNCATION),
-    Enable = proplists:get_value(lager_print_records_flag, Options, true),
-    Sinks = [lager] ++ proplists:get_value(lager_extra_sinks, Options, []),
-    Functions = proplists:get_value(lager_function_transforms, Options, []),
-    put(print_records_flag, Enable),
-    put(truncation_size, TruncSize),
-    put(sinks, Sinks),
-    put(functions, lists:keysort(1, Functions)),
-    erlang:put(records, []),
-    %% .app file should either be in the outdir, or the same dir as the source file
-    guess_application(proplists:get_value(outdir, Options), hd(AST)),
+   TruncSize = proplists:get_value(lager_truncation_size, Options, ?RumDefTruncation),
+   Enable = proplists:get_value(lager_print_records_flag, Options, true),
+   Sinks = [lager] ++ proplists:get_value(lager_extra_sinks, Options, []),
+   Functions = proplists:get_value(lager_function_transforms, Options, []),
+   put(print_records_flag, Enable),
+   put(truncation_size, TruncSize),
+   put(sinks, Sinks),
+   put(functions, lists:keysort(1, Functions)),
+   erlang:put(records, []),
+   %% .app file should either be in the outdir, or the same dir as the source file
+   guess_application(proplists:get_value(outdir, Options), hd(AST)),
     walk_ast([], AST).
 
 walk_ast(Acc, []) ->
@@ -94,14 +94,14 @@ transform_statement({call, Line, {remote, _Line1, {atom, _Line2, Module},
                     Sinks) ->
     case lists:member(Module, Sinks) of
         true ->
-            case lists:member(Function, ?LEVELS) of
+            case lists:member(Function, ?RumLevels) of
                 true ->
-                    SinkName = lager_util:make_internal_sink_name(Module),
+                    SinkName = rumUtil:make_internal_sink_name(Module),
                     do_transform(Line, SinkName, Function, Arguments0);
                 false ->
-                    case lists:keyfind(Function, 1, ?LEVELS_UNSAFE) of
+                    case lists:keyfind(Function, 1, ?RumLevelsUnsafe) of
                         {Function, Severity} ->
-                            SinkName = lager_util:make_internal_sink_name(Module),
+                            SinkName = rumUtil:make_internal_sink_name(Module),
                             do_transform(Line, SinkName, Severity, Arguments0, unsafe);
                         false ->
                             Stmt
@@ -140,7 +140,7 @@ do_transform(Line, SinkName, Severity, Arguments0) ->
     do_transform(Line, SinkName, Severity, Arguments0, safe).
 
 do_transform(Line, SinkName, Severity, Arguments0, Safety) ->
-    SeverityAsInt=lager_util:level_to_num(Severity),
+    SeverityAsInt= rumUtil:level_to_num(Severity),
     DefaultAttrs0 = {cons, Line, {tuple, Line, [
                                                 {atom, Line, module}, {atom, Line, get(module)}]},
                      {cons, Line, {tuple, Line, [
@@ -187,12 +187,12 @@ do_transform(Line, SinkName, Severity, Arguments0, Safety) ->
     %% case {whereis(Sink), whereis(?DEFAULT_SINK), lager_config:get({Sink, loglevel}, {?LOG_NONE, []})} of
     {'case',Line,
          {tuple,Line,
-                [{call,Line,{atom,Line,whereis},[{atom,Line,SinkName}]},
-                 {call,Line,{atom,Line,whereis},[{atom,Line,?DEFAULT_SINK}]}, 
-                 {call,Line,
-                       {remote,Line,{atom,Line,lager_config},{atom,Line,get}},
-                       [{tuple,Line,[{atom,Line,SinkName},{atom,Line,loglevel}]},
-                        {tuple,Line,[{integer,Line,0},{nil,Line}]}]}]},
+            [{call, Line, {atom, Line, whereis}, [{atom, Line, SinkName}]},
+               {call, Line, {atom, Line, whereis}, [{atom, Line, ?RumDefSink}]},
+               {call, Line,
+                  {remote, Line, {atom, Line, lager_config}, {atom, Line, get}},
+                  [{tuple, Line, [{atom, Line, SinkName}, {atom, Line, loglevel}]},
+                     {tuple, Line, [{integer, Line, 0}, {nil, Line}]}]}]},
          %% {undefined, undefined, _} -> {error, lager_not_running};
          [{clause,Line,
                   [{tuple,Line,

src/lager_util.erl → src/rumUtil.erl

@@ -1,34 +1,33 @@
-%% -------------------------------------------------------------------
-%%
-%% Copyright (c) 2011-2017 Basho Technologies, Inc.
-%%
-%% 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.
-%%
-%% -------------------------------------------------------------------
-
--module(lager_util).
+-module(rumUtil).
 
 -export([
-    levels/0, level_to_num/1, level_to_chr/1,
-    num_to_level/1, config_to_mask/1, config_to_levels/1, mask_to_levels/1,
-    format_time/0, format_time/1,
-    localtime_ms/0, localtime_ms/1, maybe_utc/1, parse_rotation_date_spec/1,
-    calculate_next_rotation/1, validate_trace/1, check_traces/4, is_loggable/3,
-    trace_filter/1, trace_filter/2, expand_path/1, find_file/2, check_hwm/1, check_hwm/2,
-    make_internal_sink_name/1, otp_version/0, maybe_flush/2,
-    has_file_changed/3
+    levels/0
+    , level_to_num/1
+    , level_to_chr/1
+    , num_to_level/1
+    , config_to_mask/1
+    , config_to_levels/1
+    , mask_to_levels/1
+    , format_time/0
+    , format_time/1
+    , localtime_ms/0
+    , localtime_ms/1
+    , maybe_utc/1
+    , parse_rotation_date_spec/1
+    , calculate_next_rotation/1
+    , validate_trace/1
+    , check_traces/4
+    , is_loggable/3
+    , trace_filter/1
+    , trace_filter/2
+    , expand_path/1
+    , find_file/2
+    , check_hwm/1
+    , check_hwm/2
+    , make_internal_sink_name/1
+    , otp_version/0
+    , maybe_flush/2
+    , has_file_changed/3
 ]).
 
 -ifdef(TEST).
@@ -39,7 +38,7 @@
 -include_lib("eunit/include/eunit.hrl").
 -endif.
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -include_lib("kernel/include/file.hrl").
 
@@ -332,7 +331,7 @@ calculate_next_rotation([{date, Date}|T], {{Year, Month, Day}, _} = Now) ->
 
 -spec trace_filter(Query :: 'none' | [tuple()]) -> {ok, any()}.
 trace_filter(Query) ->
-    trace_filter(?DEFAULT_TRACER, Query).
+    trace_filter(?RumDefTracer, Query).
 
 %% TODO: Support multiple trace modules
 %-spec trace_filter(Module :: atom(), Query :: 'none' | [tuple()]) -> {ok, any()}.
@@ -431,7 +430,7 @@ check_trace(Attrs, {Filter, _Level, Dest}) when is_list(Filter) ->
 
 check_trace(Attrs, {Filter, _Level, Dest}) when is_tuple(Filter) ->
     Made = gre:make(Attrs, [list]),
-    glc:handle(?DEFAULT_TRACER, Made),
+    glc:handle(?RumDefTracer, Made),
     Match = glc_lib:matches(Filter, Made),
     case Match of
         true ->
@@ -482,7 +481,7 @@ find_file(_File1, _Handlers = []) ->
     false;
 find_file(File1, [{{lager_file_backend, File2}, _Handler, _Sink} = HandlerInfo | Handlers]) ->
     File1Abs = filename:absname(File1),
-    File2Abs = filename:absname(lager_util:expand_path(File2)),
+    File2Abs = filename:absname(rumUtil:expand_path(File2)),
     case File1Abs =:= File2Abs of
         true ->
             % The file inside HandlerInfo is the same as the file we are looking
@@ -495,7 +494,7 @@ find_file(File1, [_HandlerInfo | Handlers]) ->
     find_file(File1, Handlers).
 
 %% conditionally check the HWM if the event would not have been filtered
-check_hwm(Shaper = #lager_shaper{filter = Filter}, Event) ->
+check_hwm(Shaper = #rumShaper{filter = Filter}, Event) ->
     case Filter(Event) of
         true ->
             {true, 0, Shaper};
@@ -505,18 +504,18 @@ check_hwm(Shaper = #lager_shaper{filter = Filter}, Event) ->
 
 %% Log rate limit, i.e. high water mark for incoming messages
 
-check_hwm(Shaper = #lager_shaper{hwm = undefined}) ->
+check_hwm(Shaper = #rumShaper{hwm = undefined}) ->
     {true, 0, Shaper};
-check_hwm(Shaper = #lager_shaper{mps = Mps, hwm = Hwm, lasttime = Last}) when Mps < Hwm ->
+check_hwm(Shaper = #rumShaper{mps = Mps, hwm = Hwm, lastTime = Last}) when Mps < Hwm ->
     {M, S, _} = Now = os:timestamp(),
     case Last of
         {M, S, _} ->
-            {true, 0, Shaper#lager_shaper{mps=Mps+1}};
+            {true, 0, Shaper#rumShaper{mps = Mps + 1}};
         _ ->
             %different second - reset mps
-            {true, 0, Shaper#lager_shaper{mps=1, lasttime = Now}}
+            {true, 0, Shaper#rumShaper{mps = 1, lastTime = Now}}
     end;
-check_hwm(Shaper = #lager_shaper{lasttime = Last, dropped = Drop}) ->
+check_hwm(Shaper = #rumShaper{lastTime = Last, dropped = Drop}) ->
     %% are we still in the same second?
     {M, S, _} = Now = os:timestamp(),
     case Last of
@@ -524,26 +523,26 @@ check_hwm(Shaper = #lager_shaper{lasttime = Last, dropped = Drop}) ->
             %% still in same second, but have exceeded the high water mark
             NewDrops = case should_flush(Shaper) of
                            true ->
-                               discard_messages(Now, Shaper#lager_shaper.filter, 0);
+                               discard_messages(Now, Shaper#rumShaper.filter, 0);
                            false ->
                                0
                        end,
-            Timer = case erlang:read_timer(Shaper#lager_shaper.timer) of
+            Timer = case erlang:read_timer(Shaper#rumShaper.timer) of
                         false ->
-                            erlang:send_after(trunc((1000000 - N)/1000), self(), {shaper_expired, Shaper#lager_shaper.id});
+                            erlang:send_after(trunc((1000000 - N) / 1000), self(), {shaper_expired, Shaper#rumShaper.id});
                         _ ->
-                            Shaper#lager_shaper.timer
+                            Shaper#rumShaper.timer
                     end,
-            {false, 0, Shaper#lager_shaper{dropped=Drop+NewDrops, timer=Timer}};
+            {false, 0, Shaper#rumShaper{dropped = Drop + NewDrops, timer = Timer}};
         _ ->
-            _ = erlang:cancel_timer(Shaper#lager_shaper.timer),
+            _ = erlang:cancel_timer(Shaper#rumShaper.timer),
             %% different second, reset all counters and allow it
-            {true, Drop, Shaper#lager_shaper{dropped = 0, mps=0, lasttime = Now}}
+            {true, Drop, Shaper#rumShaper{dropped = 0, mps = 0, lastTime = Now}}
     end.
 
-should_flush(#lager_shaper{flush_queue = true, flush_threshold = 0}) ->
+should_flush(#rumShaper{flushQueue = true, flushThreshold = 0}) ->
     true;
-should_flush(#lager_shaper{flush_queue = true, flush_threshold = T}) ->
+should_flush(#rumShaper{flushQueue = true, flushThreshold = T}) ->
     {_, L} = process_info(self(), message_queue_len),
     L > T;
 should_flush(_) ->
@@ -574,7 +573,7 @@ discard_messages(Second, Filter, Count) ->
 %% For historical reasons, the default gen_event process for lager itself is named
 %% `lager_event'. For all other sinks, it is SinkName++`_lager_event'
 make_internal_sink_name(lager) ->
-    ?DEFAULT_SINK;
+    ?RumDefSink;
 make_internal_sink_name(Sink) ->
     list_to_atom(atom_to_list(Sink) ++ "_lager_event").
 
@@ -590,10 +589,10 @@ otp_version() ->
         end),
     Vsn.
 
-maybe_flush(undefined, #lager_shaper{} = S) ->
+maybe_flush(undefined, #rumShaper{} = S) ->
     S;
-maybe_flush(Flag, #lager_shaper{} = S) when is_boolean(Flag) ->
-    S#lager_shaper{flush_queue = Flag}.
+maybe_flush(Flag, #rumShaper{} = S) when is_boolean(Flag) ->
+    S#rumShaper{flushQueue = Flag}.
 
 -spec has_file_changed(Name :: file:name_all(),
                        Inode0 :: pos_integer(),

test/lager_crash_backend.erl

@@ -16,7 +16,7 @@
 
 -module(lager_crash_backend).
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -behaviour(gen_event).
 

test/lager_metadata_whitelist_test.erl

@@ -7,7 +7,7 @@
 
 setup() ->
     ok = error_logger:tty(false),
-    ok = lager_util:safe_application_load(lager),
+    ok = rumUtil:safe_application_load(lager),
     ok = application:set_env(lager, handlers, [{lager_common_test_backend, info}]),
     ok = application:set_env(lager, error_logger_redirect, false),
     ok = application:unset_env(lager, traces),
@@ -24,7 +24,7 @@ cleanup(_) ->
 
 date_time_now() ->
     Now = os:timestamp(),
-    {Date, Time} = lager_util:format_time(lager_util:maybe_utc(lager_util:localtime_ms(Now))),
+    {Date, Time} = rumUtil:format_time(rumUtil:maybe_utc(rumUtil:localtime_ms(Now))),
     {Date, Time, Now}.
 
 basic_test_() ->

test/lager_rotate.erl

@@ -37,7 +37,7 @@
 rotate_test_() ->
     {foreach,
         fun() ->
-            {ok, Dir} = lager_util:create_test_dir(),
+            {ok, Dir} = rumUtil:create_test_dir(),
             Log1 = filename:join(Dir, "test1.log"),
             Log2 = filename:join(Dir, "test2.log"),
             Sink = filename:join(Dir, "sink.log"),
@@ -73,7 +73,7 @@ rotate_test_() ->
         fun(#state{}) ->
             ok = application:stop(lager),
             ok = application:stop(goldrush),
-            ok = lager_util:delete_test_dir(),
+            ok = rumUtil:delete_test_dir(),
             ok = error_logger:tty(true)
         end, [
         fun(State) ->

test/lager_slow_backend.erl

@@ -4,7 +4,7 @@
 
 -export([init/1, handle_call/2, handle_event/2, handle_info/2, terminate/2, code_change/3]).
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -record(state, {
   delay :: non_neg_integer()
@@ -14,7 +14,7 @@ init([{delay, Delay}]) ->
   {ok, #state{delay=Delay}}.
 
 handle_call(get_loglevel, State) ->
-  {ok, lager_util:config_to_mask(debug), State};
+  {ok, rumUtil:config_to_mask(debug), State};
 handle_call(_Request, State) ->
   {ok, ok, State}.
 

test/lager_test_backend.erl

@@ -25,7 +25,7 @@
 -export([init/1, handle_call/2, handle_event/2, handle_info/2, terminate/2,
         code_change/3]).
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -define(TEST_SINK_NAME, '__lager_test_sink').              %% <-- used by parse transform
 -define(TEST_SINK_EVENT, '__lager_test_sink_lager_event'). %% <-- used by lager API calls and internals for gen_event
@@ -57,7 +57,7 @@
 -endif.
 
 init(Level) ->
-    {ok, #state{level=lager_util:config_to_mask(Level), buffer=[], ignored=[]}}.
+    {ok, #state{level= rumUtil:config_to_mask(Level), buffer=[], ignored=[]}}.
 
 handle_call(count, #state{buffer=Buffer} = State) ->
     {ok, length(Buffer), State};
@@ -84,7 +84,7 @@ handle_call(get_buffer, #state{buffer=Buffer} = State) ->
 handle_call(get_loglevel, #state{level=Level} = State) ->
     {ok, Level, State};
 handle_call({set_loglevel, Level}, State) ->
-    {ok, ok, State#state{level=lager_util:config_to_mask(Level)}};
+    {ok, ok, State#state{level= rumUtil:config_to_mask(Level)}};
 handle_call(print_state, State) ->
     spawn(fun() -> lager:info("State ~p", [lager:pr(State, ?MODULE)]) end),
     timer:sleep(100),
@@ -98,7 +98,7 @@ handle_call(_Request, State) ->
 
 handle_event({log, Msg},
              #state{level=LogLevel,buffer=Buffer,ignored=Ignored} = State) ->
-    case lager_util:is_loggable(Msg, LogLevel, ?MODULE) of
+    case rumUtil:is_loggable(Msg, LogLevel, ?MODULE) of
         true ->
             {ok, State#state{buffer=Buffer ++
                              [{lager_msg:severity_as_int(Msg),
@@ -193,19 +193,19 @@ lager_test_() ->
                         lager:warning("test message"),
                         ?assertEqual(1, count()),
                         {Level, _Time, Message, _Metadata}  = pop(),
-                        ?assertMatch(Level, lager_util:level_to_num(warning)),
+                        ?assertMatch(Level, rumUtil:level_to_num(warning)),
                         ?assertEqual("test message", Message),
                         ok
                 end
             },
             {"logging with macro works",
                 fun() ->
-                        ?lager_warning("test message", []),
-                        ?assertEqual(1, count()),
-                        {Level, _Time, Message, _Metadata}  = pop(),
-                        ?assertMatch(Level, lager_util:level_to_num(warning)),
-                        ?assertEqual("test message", Message),
-                        ok
+                   ?rumWarning("test message", []),
+                   ?assertEqual(1, count()),
+                   {Level, _Time, Message, _Metadata} = pop(),
+                   ?assertMatch(Level, rumUtil:level_to_num(warning)),
+                   ?assertEqual("test message", Message),
+                   ok
                 end
             },
             {"unsafe logging works",
@@ -213,7 +213,7 @@ lager_test_() ->
                         lager:warning_unsafe("test message"),
                         ?assertEqual(1, count()),
                         {Level, _Time, Message, _Metadata}  = pop(),
-                        ?assertMatch(Level, lager_util:level_to_num(warning)),
+                        ?assertMatch(Level, rumUtil:level_to_num(warning)),
                         ?assertEqual("test message", Message),
                         ok
                 end
@@ -223,19 +223,19 @@ lager_test_() ->
                         lager:warning("test message ~p", [self()]),
                         ?assertEqual(1, count()),
                         {Level, _Time, Message,_Metadata}  = pop(),
-                        ?assertMatch(Level, lager_util:level_to_num(warning)),
+                        ?assertMatch(Level, rumUtil:level_to_num(warning)),
                         ?assertEqual(lists:flatten(io_lib:format("test message ~p", [self()])), lists:flatten(Message)),
                         ok
                 end
             },
             {"logging with macro and arguments works",
                 fun() ->
-                        ?lager_warning("test message ~p", [self()]),
-                        ?assertEqual(1, count()),
-                        {Level, _Time, Message,_Metadata}  = pop(),
-                        ?assertMatch(Level, lager_util:level_to_num(warning)),
-                        ?assertEqual(lists:flatten(io_lib:format("test message ~p", [self()])), lists:flatten(Message)),
-                        ok
+                   ?rumWarning("test message ~p", [self()]),
+                   ?assertEqual(1, count()),
+                   {Level, _Time, Message, _Metadata} = pop(),
+                   ?assertMatch(Level, rumUtil:level_to_num(warning)),
+                   ?assertEqual(lists:flatten(io_lib:format("test message ~p", [self()])), lists:flatten(Message)),
+                   ok
                 end
             },
             {"unsafe logging with args works",
@@ -243,7 +243,7 @@ lager_test_() ->
                         lager:warning_unsafe("test message ~p", [self()]),
                         ?assertEqual(1, count()),
                         {Level, _Time, Message,_Metadata}  = pop(),
-                        ?assertMatch(Level, lager_util:level_to_num(warning)),
+                        ?assertMatch(Level, rumUtil:level_to_num(warning)),
                         ?assertEqual(lists:flatten(io_lib:format("test message ~p", [self()])), lists:flatten(Message)),
                         ok
                 end
@@ -417,7 +417,7 @@ lager_test_() ->
                         lager:debug("this message will be ignored"),
                         ?assertEqual(0, count()),
                         ?assertEqual(0, count_ignored()),
-                        lager_config:set(loglevel, {element(2, lager_util:config_to_mask(debug)), []}),
+                        lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(debug)), []}),
                         lager:debug("this message should be ignored"),
                         ?assertEqual(0, count()),
                         ?assertEqual(1, count_ignored()),
@@ -432,7 +432,7 @@ lager_test_() ->
             },
             {"tracing works",
                 fun() ->
-                        lager_config:set(loglevel, {element(2, lager_util:config_to_mask(error)), []}),
+                        lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
                         ok = lager:info("hello world"),
                         ?assertEqual(0, count()),
                         lager:trace(?MODULE, [{module, ?MODULE}], debug),
@@ -449,7 +449,7 @@ lager_test_() ->
                 fun() ->
                         lager:set_loglevel(?MODULE, error),
                         ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)),
-                        lager_config:set(loglevel, {element(2, lager_util:config_to_mask(error)), []}),
+                        lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
                         lager:info([{requestid, 6}], "hello world"),
                         ?assertEqual(0, count()),
                         lager:trace(?MODULE, [{requestid, 6}, {foo, bar}], debug),
@@ -468,7 +468,7 @@ lager_test_() ->
                 fun() ->
                         lager:set_loglevel(?MODULE, error),
                         ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)),
-                        lager_config:set(loglevel, {element(2, lager_util:config_to_mask(error)), []}),
+                        lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
                         lager:info([{requestid, 6}], "hello world"),
                         ?assertEqual(0, count()),
                         lager:trace(?MODULE, [{requestid, '>', 5}, {requestid, '<', 7}, {foo, bar}], debug),
@@ -535,40 +535,40 @@ lager_test_() ->
             {"tracing custom attributes works with event stream processing statistics and reductions",
                 fun() ->
                         lager:set_loglevel(?MODULE, error),
-                        ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)),
-                        lager_config:set(loglevel, {element(2, lager_util:config_to_mask(error)), []}),
-                        lager:info([{requestid, 6}], "hello world"),
-                        ?assertEqual(0, count()),
-                        lager:trace(?MODULE, [{beta, '*'}]),
-                        lager:trace(?MODULE, [{meta, "data"}]),
-                        lager:info([{meta, "data"}], "hello world"),
-                        lager:info([{beta, 2}], "hello world"),
-                        lager:info([{beta, 2.1}, {foo, bar}], "hello world"),
-                        lager:info([{meta, <<"data">>}], "hello world"),
-                        ?assertEqual(8, ?DEFAULT_TRACER:info(input)),
-                        ?assertEqual(6, ?DEFAULT_TRACER:info(output)),
-                        ?assertEqual(2, ?DEFAULT_TRACER:info(filter)),
-                        lager:clear_all_traces(),
-                        lager:trace(?MODULE, [{meta, "data"}]),
-                        lager:trace(?MODULE, [{beta, '>', 2}, {beta, '<', 2.12}]),
-                        lager:info([{meta, "data"}], "hello world"),
-                        lager:info([{beta, 2}], "hello world"),
-                        lager:info([{beta, 2.1}, {foo, bar}], "hello world"),
-                        lager:info([{meta, <<"data">>}], "hello world"),
-                        ?assertEqual(8, ?DEFAULT_TRACER:info(input)),
-                        ?assertEqual(4, ?DEFAULT_TRACER:info(output)),
-                        ?assertEqual(4, ?DEFAULT_TRACER:info(filter)),
-                        lager:clear_all_traces(),
-                        lager:trace_console([{beta, '>', 2}, {meta, "data"}]),
-                        lager:trace_console([{beta, '>', 2}, {beta, '<', 2.12}]),
-                        Reduced = {all,[{any,[{beta,'<',2.12},{meta,'=',"data"}]},
-                                              {beta,'>',2}]},
-                        ?assertEqual(Reduced, ?DEFAULT_TRACER:info('query')),
-
-                        lager:clear_all_traces(),
-                        lager:info([{requestid, 6}], "hello world"),
-                        ?assertEqual(5, count()),
-                        ok
+                   ?assertEqual({?ERROR bor ?CRITICAL bor ?ALERT bor ?EMERGENCY, []}, lager_config:get(loglevel)),
+                   lager_config:set(loglevel, {element(2, rumUtil:config_to_mask(error)), []}),
+                   lager:info([{requestid, 6}], "hello world"),
+                   ?assertEqual(0, count()),
+                   lager:trace(?MODULE, [{beta, '*'}]),
+                   lager:trace(?MODULE, [{meta, "data"}]),
+                   lager:info([{meta, "data"}], "hello world"),
+                   lager:info([{beta, 2}], "hello world"),
+                   lager:info([{beta, 2.1}, {foo, bar}], "hello world"),
+                   lager:info([{meta, <<"data">>}], "hello world"),
+                   ?assertEqual(8, ?RumDefTracer:info(input)),
+                   ?assertEqual(6, ?RumDefTracer:info(output)),
+                   ?assertEqual(2, ?RumDefTracer:info(filter)),
+                   lager:clear_all_traces(),
+                   lager:trace(?MODULE, [{meta, "data"}]),
+                   lager:trace(?MODULE, [{beta, '>', 2}, {beta, '<', 2.12}]),
+                   lager:info([{meta, "data"}], "hello world"),
+                   lager:info([{beta, 2}], "hello world"),
+                   lager:info([{beta, 2.1}, {foo, bar}], "hello world"),
+                   lager:info([{meta, <<"data">>}], "hello world"),
+                   ?assertEqual(8, ?RumDefTracer:info(input)),
+                   ?assertEqual(4, ?RumDefTracer:info(output)),
+                   ?assertEqual(4, ?RumDefTracer:info(filter)),
+                   lager:clear_all_traces(),
+                   lager:trace_console([{beta, '>', 2}, {meta, "data"}]),
+                   lager:trace_console([{beta, '>', 2}, {beta, '<', 2.12}]),
+                   Reduced = {all, [{any, [{beta, '<', 2.12}, {meta, '=', "data"}]},
+                      {beta, '>', 2}]},
+                   ?assertEqual(Reduced, ?RumDefTracer:info('query')),
+
+                   lager:clear_all_traces(),
+                   lager:info([{requestid, 6}], "hello world"),
+                   ?assertEqual(5, count()),
+                   ok
                 end
             },
             {"persistent traces work",
@@ -605,17 +605,17 @@ lager_test_() ->
             {"stopped trace stops and removes its event handler - default sink (gh#267)",
              {timeout, 10,
                 fun() ->
-                        Sink = ?DEFAULT_SINK,
-                        StartHandlers = gen_event:which_handlers(Sink),
-                        {_, T0} = lager_config:get({Sink, loglevel}),
-                        StartGlobal = lager_config:global_get(handlers),
-                        ?assertEqual([], T0),
-                        {ok, TestTrace1} = lager:trace_file("/tmp/test", [{a,b}]),
-                        MidHandlers = gen_event:which_handlers(Sink),
-                        {ok, TestTrace2} = lager:trace_file("/tmp/test", [{c,d}]),
-                        MidHandlers = gen_event:which_handlers(Sink),
-                        ?assertEqual(length(StartHandlers)+1, length(MidHandlers)),
-                        MidGlobal = lager_config:global_get(handlers),
+                   Sink = ?RumDefSink,
+                   StartHandlers = gen_event:which_handlers(Sink),
+                   {_, T0} = lager_config:get({Sink, loglevel}),
+                   StartGlobal = lager_config:global_get(handlers),
+                   ?assertEqual([], T0),
+                   {ok, TestTrace1} = lager:trace_file("/tmp/test", [{a, b}]),
+                   MidHandlers = gen_event:which_handlers(Sink),
+                   {ok, TestTrace2} = lager:trace_file("/tmp/test", [{c, d}]),
+                   MidHandlers = gen_event:which_handlers(Sink),
+                   ?assertEqual(length(StartHandlers) + 1, length(MidHandlers)),
+                   MidGlobal = lager_config:global_get(handlers),
                         ?assertEqual(length(StartGlobal)+1, length(MidGlobal)),
                         {_, T1} = lager_config:get({Sink, loglevel}),
                         ?assertEqual(2, length(T1)),
@@ -640,8 +640,8 @@ lager_test_() ->
                 fun() ->
                         print_state(),
                         {Level, _Time, Message, _Metadata}  = pop(),
-                        ?assertMatch(Level, lager_util:level_to_num(info)),
-                        {mask, Mask} = lager_util:config_to_mask(info),
+                        ?assertMatch(Level, rumUtil:level_to_num(info)),
+                        {mask, Mask} = rumUtil:config_to_mask(info),
                         ?assertEqual("State #state{level={mask,"++integer_to_list(Mask)++"},buffer=[],ignored=[]}", lists:flatten(Message)),
                         ok
                 end
@@ -650,7 +650,7 @@ lager_test_() ->
                 fun() ->
                         print_bad_state(),
                         {Level, _Time, Message, _Metadata}  = pop(),
-                        ?assertMatch(Level, lager_util:level_to_num(info)),
+                        ?assertMatch(Level, rumUtil:level_to_num(info)),
                         ?assertEqual("State {state,1}", lists:flatten(Message)),
                         ok
                 end
@@ -660,7 +660,7 @@ lager_test_() ->
                         spawn(fun() -> lager:info("State ~p", [lager:pr({state, 1}, lager)]) end),
                         timer:sleep(100),
                         {Level, _Time, Message, _Metadata}  = pop(),
-                        ?assertMatch(Level, lager_util:level_to_num(info)),
+                        ?assertMatch(Level, rumUtil:level_to_num(info)),
                         ?assertEqual("State {state,1}", lists:flatten(Message)),
                         ok
                 end
@@ -670,7 +670,7 @@ lager_test_() ->
                         spawn(fun() -> lager:info("State ~p", [lager:pr(ok, lager)]) end),
                         timer:sleep(100),
                         {Level, _Time, Message, _Metadata}  = pop(),
-                        ?assertMatch(Level, lager_util:level_to_num(info)),
+                        ?assertMatch(Level, rumUtil:level_to_num(info)),
                         ?assertEqual("State ok", lists:flatten(Message)),
                         ok
                 end
@@ -680,7 +680,7 @@ lager_test_() ->
                         spawn(fun() -> lager:info("State ~p", [lager:pr({state, 1}, not_a_module)]) end),
                         timer:sleep(1000),
                         {Level, _Time, Message, _Metadata}  = pop(),
-                        ?assertMatch(Level, lager_util:level_to_num(info)),
+                        ?assertMatch(Level, rumUtil:level_to_num(info)),
                         ?assertEqual("State {state,1}", lists:flatten(Message)),
                         ok
                 end
@@ -766,7 +766,7 @@ extra_sinks_test_() ->
                         ?TEST_SINK_NAME:warning("test message"),
                         ?assertEqual(1, count(?TEST_SINK_EVENT)),
                         {Level, _Time, Message, _Metadata}  = pop(?TEST_SINK_EVENT),
-                        ?assertMatch(Level, lager_util:level_to_num(warning)),
+                        ?assertMatch(Level, rumUtil:level_to_num(warning)),
                         ?assertEqual("test message", Message),
                         ok
                 end
@@ -776,7 +776,7 @@ extra_sinks_test_() ->
                         ?TEST_SINK_NAME:warning("test message ~p", [self()]),
                         ?assertEqual(1, count(?TEST_SINK_EVENT)),
                         {Level, _Time, Message,_Metadata}  = pop(?TEST_SINK_EVENT),
-                        ?assertMatch(Level, lager_util:level_to_num(warning)),
+                        ?assertMatch(Level, rumUtil:level_to_num(warning)),
                         ?assertEqual(lists:flatten(io_lib:format("test message ~p", [self()])), lists:flatten(Message)),
                         ok
                 end
@@ -850,7 +850,7 @@ 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, lager_util:config_to_mask(debug)), []}),
+                        lager_config: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)),
@@ -1032,7 +1032,7 @@ crash_fsm_test_() ->
                    fun(Sink) ->
                       {Name,
                        fun() ->
-                            case {FsmModule =:= crash_statem, lager_util:otp_version() < 19} of
+                            case {FsmModule =:= crash_statem, rumUtil:otp_version() < 19} of
                                 {true, true} -> ok;
                                 _ ->
                                     Pid = whereis(FsmModule),
@@ -1040,7 +1040,7 @@ crash_fsm_test_() ->
                                     {Level, _, Msg, Metadata} = pop(Sink),
                                     test_body(Expected, lists:flatten(Msg)),
                                     ?assertEqual(Pid, proplists:get_value(pid, Metadata)),
-                                    ?assertEqual(lager_util:level_to_num(error), Level)
+                                    ?assertEqual(rumUtil:level_to_num(error), Level)
                             end
                        end
                       }
@@ -1085,7 +1085,7 @@ error_logger_redirect_crash_test_() ->
                         {Level, _, Msg,Metadata} = pop(Sink),
                         test_body(Expected, lists:flatten(Msg)),
                         ?assertEqual(Pid,proplists:get_value(pid,Metadata)),
-                        ?assertEqual(lager_util:level_to_num(error),Level)
+                        ?assertEqual(rumUtil:level_to_num(error),Level)
                 end
             }
         end
@@ -1175,7 +1175,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report([{this, is}, a, {silly, format}]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         Expected = "this: is, a, silly: format",
                         ?assertEqual(Expected, lists:flatten(Msg))
@@ -1187,7 +1187,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report("this is less silly"),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         Expected = "this is less silly",
                         ?assertEqual(Expected, lists:flatten(Msg))
@@ -1198,7 +1198,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_msg("doom, doom has come upon you all"),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         Expected = "doom, doom has come upon you all",
                         ?assertEqual(Expected, lists:flatten(Msg))
@@ -1209,7 +1209,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_msg("~ts", ["Привет!"]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Привет!", lists:flatten(Msg))
                 end
@@ -1228,7 +1228,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:info_report([{this, is}, a, {silly, format}]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(info),Level),
+                        ?assertEqual(rumUtil:level_to_num(info),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         Expected = "this: is, a, silly: format",
                         ?assertEqual(Expected, lists:flatten(Msg))
@@ -1239,7 +1239,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:info_report([[{this, is}, a, {silly, format}] || _ <- lists:seq(0, 600)]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(info),Level),
+                        ?assertEqual(rumUtil:level_to_num(info),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assert(length(lists:flatten(Msg)) < 5000)
                 end
@@ -1249,7 +1249,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:info_report({foolish, bees}),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(info),Level),
+                        ?assertEqual(rumUtil:level_to_num(info),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("{foolish,bees}", lists:flatten(Msg))
                 end
@@ -1259,7 +1259,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report({foolish, bees}),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("{foolish,bees}", lists:flatten(Msg))
                 end
@@ -1269,7 +1269,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:info_report("this is less silly"),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(info),Level),
+                        ?assertEqual(rumUtil:level_to_num(info),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("this is less silly", lists:flatten(Msg))
                 end
@@ -1279,7 +1279,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:info_report(string:copies("this is less silly", 1000)),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(info),Level),
+                        ?assertEqual(rumUtil:level_to_num(info),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assert(length(lists:flatten(Msg)) < 5100)
                 end
@@ -1289,7 +1289,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:info_report(["this is less silly", {than, "this"}]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(info),Level),
+                        ?assertEqual(rumUtil:level_to_num(info),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("\"this is less silly\", than: \"this\"", lists:flatten(Msg))
                 end
@@ -1299,7 +1299,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:info_msg("doom, doom has come upon you all"),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(info),Level),
+                        ?assertEqual(rumUtil:level_to_num(info),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("doom, doom has come upon you all", lists:flatten(Msg))
                 end
@@ -1309,7 +1309,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:info_msg("doom, doom has come upon you all ~p", [string:copies("doom", 10000)]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(info),Level),
+                        ?assertEqual(rumUtil:level_to_num(info),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assert(length(lists:flatten(Msg)) < 5100)
                 end
@@ -1319,7 +1319,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:info_msg("~ts", ["Привет!"]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(info),Level),
+                        ?assertEqual(rumUtil:level_to_num(info),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Привет!", lists:flatten(Msg))
                 end
@@ -1348,7 +1348,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:warning_msg("~ts", ["Привет!"]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(Lvl),Level),
+                        ?assertEqual(rumUtil:level_to_num(Lvl),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Привет!", lists:flatten(Msg))
                 end
@@ -1360,7 +1360,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:warning_msg("doom, doom has come upon you all"),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(Lvl),Level),
+                        ?assertEqual(rumUtil:level_to_num(Lvl),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("doom, doom has come upon you all", lists:flatten(Msg))
                 end
@@ -1372,7 +1372,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:warning_report([{i, like}, pie]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(Lvl),Level),
+                        ?assertEqual(rumUtil:level_to_num(Lvl),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("i: like, pie", lists:flatten(Msg))
                 end
@@ -1384,7 +1384,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:warning_report({foolish, bees}),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(Lvl),Level),
+                        ?assertEqual(rumUtil:level_to_num(Lvl),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("{foolish,bees}", lists:flatten(Msg))
                 end
@@ -1394,7 +1394,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:info_report([{application, foo}, {exited, quittin_time}, {type, lazy}]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(info),Level),
+                        ?assertEqual(rumUtil:level_to_num(info),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Application foo exited with reason: quittin_time", lists:flatten(Msg))
                 end
@@ -1404,7 +1404,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report(supervisor_report, [{errorContext, france}, {offender, [{name, mini_steve}, {mfargs, {a, b, [c]}}, {pid, bleh}]}, {reason, fired}, {supervisor, {local, steve}}]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Supervisor steve had child mini_steve started with a:b(c) at bleh exit with reason fired in context france", lists:flatten(Msg))
                 end
@@ -1414,7 +1414,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report(supervisor_report, [{errorContext, france}, {offender, [{name, mini_steve}, {mfargs, {a, b, [c]}}, {pid, bleh}]}, {reason, {function_clause,[{crash,handle_info,[foo]}]}}, {supervisor, {local, steve}}]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Supervisor steve had child mini_steve started with a:b(c) at bleh exit with reason no function clause matching crash:handle_info(foo) in context france", lists:flatten(Msg))
                 end
@@ -1425,7 +1425,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report(supervisor_report, [{errorContext, france}, {offender, [{name, mini_steve}, {mfargs, {a, b, [c]}}, {pid, bleh}]}, {reason, {function_clause,[{crash,handle_info,[foo]}]}}, {supervisor, somepid}]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Supervisor somepid had child mini_steve started with a:b(c) at bleh exit with reason no function clause matching crash:handle_info(foo) in context france", lists:flatten(Msg))
                 end
@@ -1436,7 +1436,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report(supervisor_report, [{errorContext, france}, {offender, [{mod, mini_steve}, {pid, bleh}]}, {reason, fired}, {supervisor, {local, steve}}]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Supervisor steve had child at module mini_steve at bleh exit with reason fired in context france", lists:flatten(Msg))
                 end
@@ -1446,7 +1446,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:info_report(progress, [{application, foo}, {started_at, node()}]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(info),Level),
+                        ?assertEqual(rumUtil:level_to_num(info),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         Expected = lists:flatten(io_lib:format("Application foo started on node ~w", [node()])),
                         ?assertEqual(Expected, lists:flatten(Msg))
@@ -1459,7 +1459,7 @@ error_logger_redirect_test_() ->
                         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),
-                        ?assertEqual(lager_util:level_to_num(debug),Level),
+                        ?assertEqual(rumUtil:level_to_num(debug),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Supervisor foo started foo:bar/1 at pid baz", lists:flatten(Msg))
                 end
@@ -1471,7 +1471,7 @@ error_logger_redirect_test_() ->
                         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),
-                        ?assertEqual(lager_util:level_to_num(debug),Level),
+                        ?assertEqual(rumUtil:level_to_num(debug),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Supervisor somepid started foo:bar/1 at pid baz", lists:flatten(Msg))
                 end
@@ -1481,7 +1481,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report(crash_report, [[{pid, self()}, {registered_name, []}, {error_info, {error, emfile, [{stack, trace, 1}]}}], []]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         Expected = lists:flatten(io_lib:format("CRASH REPORT Process ~w with 0 neighbours crashed with reason: maximum number of file descriptors exhausted, check ulimit -n", [self()])),
                         ?assertEqual(Expected, lists:flatten(Msg))
@@ -1492,7 +1492,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report(crash_report, [[{pid, self()}, {registered_name, []}, {error_info, {error, system_limit, [{erlang, spawn, 1}]}}], []]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         Expected = lists:flatten(io_lib:format("CRASH REPORT Process ~w with 0 neighbours crashed with reason: system limit: maximum number of processes exceeded", [self()])),
                         ?assertEqual(Expected, lists:flatten(Msg))
@@ -1503,7 +1503,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report(crash_report, [[{pid, self()}, {registered_name, []}, {error_info, {error, system_limit, [{erlang, spawn_opt, 1}]}}], []]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         Expected = lists:flatten(io_lib:format("CRASH REPORT Process ~w with 0 neighbours crashed with reason: system limit: maximum number of processes exceeded", [self()])),
                         ?assertEqual(Expected, lists:flatten(Msg))
@@ -1514,7 +1514,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report(crash_report, [[{pid, self()}, {registered_name, []}, {error_info, {error, system_limit, [{erlang, open_port, 1}]}}], []]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         Expected = lists:flatten(io_lib:format("CRASH REPORT Process ~w with 0 neighbours crashed with reason: system limit: maximum number of ports exceeded", [self()])),
                         ?assertEqual(Expected, lists:flatten(Msg))
@@ -1525,7 +1525,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report(crash_report, [[{pid, self()}, {registered_name, []}, {error_info, {error, system_limit, [{erlang, list_to_atom, 1}]}}], []]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         Expected = lists:flatten(io_lib:format("CRASH REPORT Process ~w with 0 neighbours crashed with reason: system limit: tried to create an atom larger than 255, or maximum atom count exceeded", [self()])),
                         ?assertEqual(Expected, lists:flatten(Msg))
@@ -1536,7 +1536,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_report(crash_report, [[{pid, self()}, {registered_name, test}, {error_info, {error, system_limit, [{ets,new,[segment_offsets,[ordered_set,public]]},{mi_segment,open_write,1},{mi_buffer_converter,handle_cast,2},{gen_server,handle_msg,5},{proc_lib,init_p_do_apply,3}]}}], []]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         Expected = lists:flatten(io_lib:format("CRASH REPORT Process ~w with 0 neighbours crashed with reason: system limit: maximum number of ETS tables exceeded", [test])),
                         ?assertEqual(Expected, lists:flatten(Msg))
@@ -1612,7 +1612,7 @@ error_logger_redirect_test_() ->
                         sync_error_logger:error_msg("webmachine error: path=~p~n~p~n", [Path, Reason]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Webmachine error at path \"/cgi-bin/phpmyadmin\" : no match of right hand value {error,timeout} in myapp:dostuff/2 line 123", lists:flatten(Msg))
 
@@ -1633,7 +1633,7 @@ error_logger_redirect_test_() ->
                              "Request", Stack]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Cowboy handler my_handler terminated in my_handler:init/3 with reason: no match of right hand value {error,timeout} in my_handler:init/3 line 123", lists:flatten(Msg))
                 end
@@ -1652,7 +1652,7 @@ error_logger_redirect_test_() ->
 
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Cowboy handler my_handler terminated in my_handler:somecallback/3 with reason: no match of right hand value {error,timeout} in my_handler:somecallback/3 line 123", lists:flatten(Msg))
                 end
@@ -1666,7 +1666,7 @@ error_logger_redirect_test_() ->
                             [my_handler, to_json, 2, "Request", {}]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg,Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error),Level),
+                        ?assertEqual(rumUtil:level_to_num(error),Level),
                         ?assertEqual(self(),proplists:get_value(pid,Metadata)),
                         ?assertEqual("Cowboy handler my_handler terminated with reason: call to undefined function my_handler:to_json/2", lists:flatten(Msg))
                 end
@@ -1683,7 +1683,7 @@ error_logger_redirect_test_() ->
                             [my_listner, ConnectionPid, 1, self(), {badmatch, 2}, Stack]),
                         _ = gen_event:which_handlers(error_logger),
                         {Level, _, Msg, Metadata} = pop(Sink),
-                        ?assertEqual(lager_util:level_to_num(error), Level),
+                        ?assertEqual(rumUtil:level_to_num(error), Level),
                         ?assertEqual(self(), proplists:get_value(pid, Metadata)),
                         ?assertEqual("Cowboy stream 1 with ranch listener my_listner and "
                                      "connection process <0.82.0> had its request process exit "
@@ -1707,7 +1707,7 @@ error_logger_redirect_test_() ->
                         ?assertEqual(0, count_ignored(Sink)),
                         lager: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, lager_util:config_to_mask(debug)), []}),
+                        lager_config: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)),
@@ -1785,7 +1785,7 @@ async_threshold_test_() ->
 
             %% put a ton of things in the queue
             WorkCnt = erlang:max(10, (erlang:system_info(schedulers) * 2)),
-            OtpVsn  = lager_util:otp_version(),
+            OtpVsn  = rumUtil:otp_version(),
             % newer OTPs *may* handle the messages faster, so we'll send more
             MsgCnt  = ((OtpVsn * OtpVsn) div 2),
             Workers = spawn_stuffers(WorkCnt, [MsgCnt, info, "hello world"], []),

test/lager_test_function_transform.erl

@@ -20,7 +20,7 @@
 
 -module(lager_test_function_transform).
 
--include("lager.hrl").
+-include("rum.hrl").
 
 -compile([{nowarn_deprecated_function, [{erlang, now, 0}]}]).
 
@@ -49,7 +49,7 @@ transform_static() ->
     static_result.
 
 transform_dynamic() ->
-    case lager_util:otp_version() >= 18 of
+    case rumUtil:otp_version() >= 18 of
         true ->
             erlang:monotonic_time();
         false ->
@@ -61,7 +61,7 @@ not_running_test() ->
 
 setup() ->
     ok = error_logger:tty(false),
-    ok = lager_util:safe_application_load(lager),
+    ok = rumUtil:safe_application_load(lager),
     ok = application:set_env(lager, handlers, [{lager_test_backend, info}]),
     ok = application:set_env(lager, error_logger_redirect, false),
     ok = application:unset_env(lager, traces),
@@ -102,7 +102,7 @@ transform_function_test_() ->
                     lager:warning("test message"),
                     ?assertEqual(1, lager_test_backend:count()),
                     {Level, _Time, Message, _Metadata}  = lager_test_backend:pop(),
-                    ?assertMatch(Level, lager_util:level_to_num(warning)),
+                    ?assertMatch(Level, rumUtil:level_to_num(warning)),
                     ?assertEqual("test message", Message),
                     ok
                 end