ft:修改

include/rum.hrl

@@ -59,7 +59,7 @@
 -define(RunShouldLog(Level), (rumUtil:level_to_num(Level) band element(1, rumConfig:get(loglevel, {?LOG_NONE, []}))) /= 0).
 
 -define(RunNotify(Level, Pid, Format, Args),
-   gen_event:notify(lager_event, {log, lager_msg:new(io_lib:format(Format, Args), Level, [{pid, Pid}, {line, ?LINE}, {file, ?FILE}, {module, ?MODULE}], [])})).
+   gen_event:notify(lager_event, {log, rumMsg:new(io_lib:format(Format, Args), Level, [{pid, Pid}, {line, ?LINE}, {file, ?FILE}, {module, ?MODULE}], [])})).
 
 %%仅供内部使用仅内部非阻塞日志记录调用，当我们仍在启动大型啤酒时尝试进行日志记录（通常为错误）时，会有一些特殊处理。
 -ifdef(TEST).
@@ -150,4 +150,13 @@
    , filter = fun(_) -> false end :: fun()
 }).
 
+-record(rumMsg, {
+   destinations :: list(),
+   metadata :: [tuple()],
+   severity :: eRum:log_level(),
+   datetime :: {string(), string()},
+   timestamp :: erlang:timestamp(),
+   message :: list()
+}).
+
 -type rumShaper() :: #rumShaper{}.

src/misc/lager_backend_throttle.erl → src/backend/rumBackendThrottle.erl

@@ -20,7 +20,7 @@
 %% size doesn't involve getting a lock, and gen_event handlers run in their
 %% parent's process.
 
--module(lager_backend_throttle).
+-module(rumBackendThrottle).
 
 -include("rum.hrl").
 

src/misc/lager_console_backend.erl → src/backend/rumConsoleBackend.erl

@@ -26,7 +26,7 @@
 %%                             `time [ severity ] message'</li>
 %% </ul>
 
--module(lager_console_backend).
+-module(rumConsoleBackend).
 
 -behaviour(gen_event).
 

src/misc/lager_file_backend.erl → src/backend/rumFileBackend.erl

@@ -1,23 +1,3 @@
-%% -------------------------------------------------------------------
-%%
-%% 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.
-%%
-%% -------------------------------------------------------------------
-
 %% @doc File backend for lager, with multiple file support.
 %% Multiple files are supported, each with the path and the loglevel being
 %% configurable. The configuration paramter for this backend is a list of
@@ -32,7 +12,7 @@
 %% sync at specific log levels, configured via the `sync_on' option. By default
 %% the error level or above will trigger a sync.
 
--module(lager_file_backend).
+-module(rumFileBackend).
 
 -include("rum.hrl").
 -include_lib("kernel/include/file.hrl").
@@ -172,14 +152,14 @@ handle_event({log, Message},
                                 Report = io_lib:format(
                                    "lager_file_backend dropped ~p messages in the last second that exceeded the limit of ~p messages/sec",
                                    [Drop, Hwm]),
-                                ReportMsg = lager_msg:new(Report, warning, [], []),
-                                write(State, lager_msg:timestamp(ReportMsg),
-                                   lager_msg:severity_as_int(ReportMsg), Formatter:format(ReportMsg, FormatConfig));
+                                ReportMsg = rumMsg:new(Report, warning, [], []),
+                                write(State, rumMsg:timestamp(ReportMsg),
+                                   rumMsg:severity_as_int(ReportMsg), Formatter:format(ReportMsg, FormatConfig));
                              false ->
                                 State
                           end,
                {ok, write(NewState#state{shaper = NewShaper},
-                  lager_msg:timestamp(Message), lager_msg:severity_as_int(Message),
+                  rumMsg:timestamp(Message), rumMsg:severity_as_int(Message),
                   Formatter:format(Message, FormatConfig))};
             {false, _, #rumShaper{dropped = D} = NewShaper} ->
                {ok, State#state{shaper = NewShaper#rumShaper{dropped = D + 1}}}
@@ -204,9 +184,9 @@ handle_info({shaper_expired, Name}, #state{shaper = Shaper, name = Name, formatt
              Report = io_lib:format(
                 "lager_file_backend dropped ~p messages in the last second that exceeded the limit of ~p messages/sec",
                 [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))
+             ReportMsg = rumMsg:new(Report, warning, [], []),
+             write(State, rumMsg:timestamp(ReportMsg),
+                rumMsg:severity_as_int(ReportMsg), Formatter:format(ReportMsg, FormatConfig))
        end,
    {ok, State#state{shaper = Shaper#rumShaper{dropped = 0, mps = 0, lastTime = os:timestamp()}}};
 handle_info(_Info, State) ->

src/eRum.app.src

@@ -4,7 +4,7 @@
       {vsn, "0.1.0"},
       {modules, []},
       {applications, [kernel, stdlib, goldrush]},
-      {registered, [eRum_sup, lager_event, lager_crash_log, lager_handler_watcher_sup]},
+      {registered, [eRum_sup, lager_event, rumCrashLog, rumHandlerWatcherSup]},
       {mod, {eRum_app, []}},
       {env, [
          %% Note: application:start(lager) overwrites previously defined environment variables thus declaration of default handlers is done at lager_app.erl

src/eRum.erl

@@ -149,7 +149,7 @@ do_log_impl(Severity, Metadata, Format, Args, SeverityAsInt, LevelThreshold, Tra
                   _ ->
                      Format
                end,
-         LagerMsg = lager_msg:new(Msg,
+         LagerMsg = rumMsg:new(Msg,
             Severity, Metadata, Destinations),
          case rumConfig:get({Sink, async}, false) of
             true ->
@@ -548,9 +548,9 @@ safe_format(Fmt, Args, Limit) ->
    safe_format(Fmt, Args, Limit, []).
 
 safe_format(Fmt, Args, Limit, Options) ->
-   try lager_trunc_io:format(Fmt, Args, Limit, Options)
+   try rumTruncIo:format(Fmt, Args, Limit, Options)
    catch
-      _:_ -> lager_trunc_io:format("FORMAT ERROR: ~p ~p", [Fmt, Args], Limit)
+      _:_ -> rumTruncIo:format("FORMAT ERROR: ~p ~p", [Fmt, Args], Limit)
    end.
 
 %% @private
@@ -652,7 +652,7 @@ pr_stacktrace_(Stacktrace) ->
    Indent = "\n    ",
    lists:foldl(
       fun(Entry, Acc) ->
-         Acc ++ Indent ++ error_logger_lager_h:format_mfa(Entry)
+         Acc ++ Indent ++ rumErrLoggerH:format_mfa(Entry)
       end,
       [],
       Stacktrace).

src/eRum_app.erl

@@ -259,7 +259,7 @@ expand_handlers([{lager_file_backend, [{Key, _Value} | _] = Config} | T]) when i
    [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] ++
+   [{rumFileBackend: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)];

src/formatter/rumFormat.erl

@@ -231,25 +231,25 @@ control(C, A, F, Adj, P, Pad, Enc, L) ->
    {{C, A, F, Adj, P, Pad, Enc}, L}.
 
 control2($w, [A], F, Adj, P, Pad, _Enc, L) ->
-   Term = lager_trunc_io:fprint(A, L, [{lists_as_strings, false}]),
+   Term = rumTruncIo:fprint(A, L, [{lists_as_strings, false}]),
    Res = term(Term, F, Adj, P, Pad),
    {Res, lists:flatlength(Res)};
 control2($p, [A], _F, _Adj, _P, _Pad, _Enc, L) ->
-   Term = lager_trunc_io:fprint(A, L, [{lists_as_strings, true}]),
+   Term = rumTruncIo:fprint(A, L, [{lists_as_strings, true}]),
    {Term, lists:flatlength(Term)};
 control2($W, [A, Depth], F, Adj, P, Pad, _Enc, L) when is_integer(Depth) ->
-   Term = lager_trunc_io:fprint(A, L, [{depth, Depth}, {lists_as_strings, false}]),
+   Term = rumTruncIo:fprint(A, L, [{depth, Depth}, {lists_as_strings, false}]),
    Res = term(Term, F, Adj, P, Pad),
    {Res, lists:flatlength(Res)};
 control2($P, [A, Depth], _F, _Adj, _P, _Pad, _Enc, L) when is_integer(Depth) ->
-   Term = lager_trunc_io:fprint(A, L, [{depth, Depth}, {lists_as_strings, true}]),
+   Term = rumTruncIo:fprint(A, L, [{depth, Depth}, {lists_as_strings, true}]),
    {Term, lists:flatlength(Term)};
 control2($s, [L0], F, Adj, P, Pad, latin1, L) ->
-   List = lager_trunc_io:fprint(iolist_to_chars(L0), L, [{force_strings, true}]),
+   List = rumTruncIo:fprint(iolist_to_chars(L0), L, [{force_strings, true}]),
    Res = string(List, F, Adj, P, Pad),
    {Res, lists:flatlength(Res)};
 control2($s, [L0], F, Adj, P, Pad, unicode, L) ->
-   List = lager_trunc_io:fprint(cdata_to_chars(L0), L, [{force_strings, true}]),
+   List = rumTruncIo:fprint(cdata_to_chars(L0), L, [{force_strings, true}]),
    Res = uniconv(string(List, F, Adj, P, Pad)),
    {Res, lists:flatlength(Res)}.
 

src/formatter/rumFormatter.erl

@@ -53,7 +53,7 @@
 %%
 %%    `[{pid, ["My pid is ", pid], ["Unknown Pid"]}]' -> if pid is in the metada print "My pid is ?.?.?", otherwise print "Unknown Pid"
 %% @end
--spec format(lager_msg:lager_msg(), list(), list()) -> any().
+-spec format(rumMsg:rumMsg(), list(), list()) -> any().
 format(Msg, [], Colors) ->
    format(Msg, [{eol, "\n"}], Colors);
 format(Msg, [{eol, EOL}], Colors) ->
@@ -68,22 +68,22 @@ format(Message, Config, Colors) ->
        _ -> output(V, Message)
     end || V <- Config].
 
--spec format(lager_msg:lager_msg(), list()) -> any().
+-spec format(rumMsg:rumMsg(), list()) -> any().
 format(Msg, Config) ->
    format(Msg, Config, []).
 
--spec output(term(), lager_msg:lager_msg()) -> iolist().
-output(message, Msg) -> lager_msg:message(Msg);
+-spec output(term(), rumMsg:rumMsg()) -> iolist().
+output(message, Msg) -> rumMsg:message(Msg);
 output(date, Msg) ->
-   {D, _T} = lager_msg:datetime(Msg),
+   {D, _T} = rumMsg:datetime(Msg),
    D;
 output(time, Msg) ->
-   {_D, T} = lager_msg:datetime(Msg),
+   {_D, T} = rumMsg:datetime(Msg),
    T;
 output(severity, Msg) ->
-   atom_to_list(lager_msg:severity(Msg));
+   atom_to_list(rumMsg:severity(Msg));
 output(severity_upper, Msg) ->
-   uppercase_severity(lager_msg:severity(Msg));
+   uppercase_severity(rumMsg:severity(Msg));
 output(blank, _Msg) ->
    output({blank, " "}, _Msg);
 output(node, _Msg) ->
@@ -92,25 +92,25 @@ output({blank, Fill}, _Msg) ->
    Fill;
 output(sev, Msg) ->
    %% Write brief acronym for the severity level (e.g. debug -> $D)
-   [rumUtil:level_to_chr(lager_msg:severity(Msg))];
+   [rumUtil:level_to_chr(rumMsg:severity(Msg))];
 output(metadata, Msg) ->
    output({metadata, "=", " "}, Msg);
 output({metadata, IntSep, FieldSep}, Msg) ->
-   MD = lists:keysort(1, lager_msg:metadata(Msg)),
+   MD = lists:keysort(1, rumMsg:metadata(Msg)),
    string:join([io_lib:format("~s~s~p", [K, IntSep, V]) || {K, V} <- MD], FieldSep);
 output({pterm, Key}, Msg) ->
    output({pterm, Key, ""}, Msg);
 output({pterm, Key, Default}, _Msg) ->
    make_printable(maybe_get_persistent_term(Key, Default));
 output(Prop, Msg) when is_atom(Prop) ->
-   Metadata = lager_msg:metadata(Msg),
+   Metadata = rumMsg:metadata(Msg),
    make_printable(get_metadata(Prop, Metadata, <<"Undefined">>));
 output({Prop, Default}, Msg) when is_atom(Prop) ->
-   Metadata = lager_msg:metadata(Msg),
+   Metadata = rumMsg:metadata(Msg),
    make_printable(get_metadata(Prop, Metadata, output(Default, Msg)));
 output({Prop, Present, Absent}, Msg) when is_atom(Prop) ->
    %% sort of like a poor man's ternary operator
-   Metadata = lager_msg:metadata(Msg),
+   Metadata = rumMsg:metadata(Msg),
    case get_metadata(Prop, Metadata) of
       undefined ->
          [output(V, Msg) || V <- Absent];
@@ -119,7 +119,7 @@ output({Prop, Present, Absent}, Msg) when is_atom(Prop) ->
    end;
 output({Prop, Present, Absent, Width}, Msg) when is_atom(Prop) ->
    %% sort of like a poor man's ternary operator
-   Metadata = lager_msg:metadata(Msg),
+   Metadata = rumMsg:metadata(Msg),
    case get_metadata(Prop, Metadata) of
       undefined ->
          [output(V, Msg, Width) || V <- Absent];
@@ -128,18 +128,18 @@ output({Prop, Present, Absent, Width}, Msg) when is_atom(Prop) ->
    end;
 output(Other, _) -> make_printable(Other).
 
-output(message, Msg, _Width) -> lager_msg:message(Msg);
+output(message, Msg, _Width) -> rumMsg:message(Msg);
 output(date, Msg, _Width) ->
-   {D, _T} = lager_msg:datetime(Msg),
+   {D, _T} = rumMsg:datetime(Msg),
    D;
 output(time, Msg, _Width) ->
-   {_D, T} = lager_msg:datetime(Msg),
+   {_D, T} = rumMsg:datetime(Msg),
    T;
 output(severity, Msg, Width) ->
-   make_printable(atom_to_list(lager_msg:severity(Msg)), Width);
+   make_printable(atom_to_list(rumMsg:severity(Msg)), Width);
 output(sev, Msg, _Width) ->
    %% Write brief acronym for the severity level (e.g. debug -> $D)
-   [rumUtil:level_to_chr(lager_msg:severity(Msg))];
+   [rumUtil:level_to_chr(rumMsg:severity(Msg))];
 output(node, Msg, _Width) ->
    output({node, atom_to_list(node())}, Msg, _Width);
 output(blank, _Msg, _Width) ->
@@ -149,7 +149,7 @@ output({blank, Fill}, _Msg, _Width) ->
 output(metadata, Msg, _Width) ->
    output({metadata, "=", " "}, Msg, _Width);
 output({metadata, IntSep, FieldSep}, Msg, _Width) ->
-   MD = lists:keysort(1, lager_msg:metadata(Msg)),
+   MD = lists:keysort(1, rumMsg:metadata(Msg)),
    [string:join([io_lib:format("~s~s~p", [K, IntSep, V]) || {K, V} <- MD], FieldSep)];
 output({pterm, Key}, Msg, Width) ->
    output({pterm, Key, ""}, Msg, Width);
@@ -157,16 +157,16 @@ output({pterm, Key, Default}, _Msg, _Width) ->
    make_printable(maybe_get_persistent_term(Key, Default));
 
 output(Prop, Msg, Width) when is_atom(Prop) ->
-   Metadata = lager_msg:metadata(Msg),
+   Metadata = rumMsg:metadata(Msg),
    make_printable(get_metadata(Prop, Metadata, <<"Undefined">>), Width);
 output({Prop, Default}, Msg, Width) when is_atom(Prop) ->
-   Metadata = lager_msg:metadata(Msg),
+   Metadata = rumMsg:metadata(Msg),
    make_printable(get_metadata(Prop, Metadata, output(Default, Msg)), Width);
 output(Other, _, Width) -> make_printable(Other, Width).
 
 output_color(_Msg, []) -> [];
 output_color(Msg, Colors) ->
-   Level = lager_msg:severity(Msg),
+   Level = rumMsg:severity(Msg),
    case lists:keyfind(Level, 1, Colors) of
       {_, Color} -> Color;
       _ -> []
@@ -275,7 +275,7 @@ basic_test_() ->
    {Date, Time, Now} = date_time_now(),
    [{"Default formatting test",
       ?_assertEqual(iolist_to_binary([Date, " ", Time, " [error] ", pid_to_list(self()), " Message\n"]),
-         iolist_to_binary(format(lager_msg:new("Message",
+         iolist_to_binary(format(rumMsg:new("Message",
             Now,
             error,
             [{pid, self()}],
@@ -284,7 +284,7 @@ basic_test_() ->
    },
       {"Basic Formatting",
          ?_assertEqual(<<"Simplist Format">>,
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, self()}],
@@ -293,7 +293,7 @@ basic_test_() ->
       },
       {"Default equivalent formatting test",
          ?_assertEqual(iolist_to_binary([Date, " ", Time, " [error] ", pid_to_list(self()), " Message\n"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, self()}],
@@ -303,7 +303,7 @@ basic_test_() ->
       },
       {"Non existent metadata can default to string",
          ?_assertEqual(iolist_to_binary([Date, " ", Time, " [error] Fallback Message\n"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, self()}],
@@ -313,7 +313,7 @@ basic_test_() ->
       },
       {"Non existent metadata can default to other metadata",
          ?_assertEqual(iolist_to_binary([Date, " ", Time, " [error] Fallback Message\n"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, "Fallback"}],
@@ -323,7 +323,7 @@ basic_test_() ->
       },
       {"Non existent metadata can default to a string2",
          ?_assertEqual(iolist_to_binary(["Unknown Pid"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [],
@@ -333,7 +333,7 @@ basic_test_() ->
       },
       {"Metadata can have extra formatting",
          ?_assertEqual(iolist_to_binary(["My pid is hello"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, hello}],
@@ -343,7 +343,7 @@ basic_test_() ->
       },
       {"Metadata can have extra formatting1",
          ?_assertEqual(iolist_to_binary(["servername"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, hello}, {server, servername}],
@@ -353,7 +353,7 @@ basic_test_() ->
       },
       {"Metadata can have extra formatting2",
          ?_assertEqual(iolist_to_binary(["(hello)"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, hello}],
@@ -363,7 +363,7 @@ basic_test_() ->
       },
       {"Metadata can have extra formatting3",
          ?_assertEqual(iolist_to_binary(["(Unknown Server)"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [],
@@ -373,7 +373,7 @@ basic_test_() ->
       },
       {"Metadata can be printed in its enterity",
          ?_assertEqual(iolist_to_binary(["bar=2 baz=3 foo=1"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{foo, 1}, {bar, 2}, {baz, 3}],
@@ -383,7 +383,7 @@ basic_test_() ->
       },
       {"Metadata can be printed in its enterity with custom seperators",
          ?_assertEqual(iolist_to_binary(["bar->2, baz->3, foo->1"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{foo, 1}, {bar, 2}, {baz, 3}],
@@ -393,7 +393,7 @@ basic_test_() ->
       },
       {"Metadata can have extra formatting with width 1",
          ?_assertEqual(iolist_to_binary(["(hello     )(hello     )(hello)(hello)(hello)"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, hello}],
@@ -407,7 +407,7 @@ basic_test_() ->
       },
       {"Metadata can have extra formatting with width 2",
          ?_assertEqual(iolist_to_binary(["(hello     )"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, hello}],
@@ -417,7 +417,7 @@ basic_test_() ->
       },
       {"Metadata can have extra formatting with width 3",
          ?_assertEqual(iolist_to_binary(["(     hello)"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, hello}],
@@ -427,7 +427,7 @@ basic_test_() ->
       },
       {"Metadata can have extra formatting with width 4",
          ?_assertEqual(iolist_to_binary(["(  hello   )"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, hello}],
@@ -437,7 +437,7 @@ basic_test_() ->
       },
       {"Metadata can have extra formatting with width 5",
          ?_assertEqual(iolist_to_binary(["error     |hello     ! (  hello   )"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, hello}],
@@ -447,7 +447,7 @@ basic_test_() ->
       },
       {"Metadata can have extra formatting with width 6",
          ?_assertEqual(iolist_to_binary([Time, Date, " bar=2 baz=3 foo=1 pid=hello EMessage"]),
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, hello}, {foo, 1}, {bar, 2}, {baz, 3}],
@@ -457,7 +457,7 @@ basic_test_() ->
       },
       {"Uppercase Severity Formatting - DEBUG",
          ?_assertEqual(<<"DEBUG Simplist Format">>,
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                debug,
                [{pid, self()}],
@@ -466,7 +466,7 @@ basic_test_() ->
       },
       {"Uppercase Severity Formatting - INFO",
          ?_assertEqual(<<"INFO Simplist Format">>,
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                info,
                [{pid, self()}],
@@ -475,7 +475,7 @@ basic_test_() ->
       },
       {"Uppercase Severity Formatting - NOTICE",
          ?_assertEqual(<<"NOTICE Simplist Format">>,
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                notice,
                [{pid, self()}],
@@ -484,7 +484,7 @@ basic_test_() ->
       },
       {"Uppercase Severity Formatting - WARNING",
          ?_assertEqual(<<"WARNING Simplist Format">>,
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                warning,
                [{pid, self()}],
@@ -493,7 +493,7 @@ basic_test_() ->
       },
       {"Uppercase Severity Formatting - ERROR",
          ?_assertEqual(<<"ERROR Simplist Format">>,
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                error,
                [{pid, self()}],
@@ -502,7 +502,7 @@ basic_test_() ->
       },
       {"Uppercase Severity Formatting - CRITICAL",
          ?_assertEqual(<<"CRITICAL Simplist Format">>,
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                critical,
                [{pid, self()}],
@@ -511,7 +511,7 @@ basic_test_() ->
       },
       {"Uppercase Severity Formatting - ALERT",
          ?_assertEqual(<<"ALERT Simplist Format">>,
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                alert,
                [{pid, self()}],
@@ -520,7 +520,7 @@ basic_test_() ->
       },
       {"Uppercase Severity Formatting - EMERGENCY",
          ?_assertEqual(<<"EMERGENCY Simplist Format">>,
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                emergency,
                [{pid, self()}],
@@ -534,7 +534,7 @@ basic_test_() ->
                ?_assertEqual(<<"Pterm is: something">>,
                   begin
                      persistent_term:put(thing, something),
-                     Ret = iolist_to_binary(format(lager_msg:new("Message",
+                     Ret = iolist_to_binary(format(rumMsg:new("Message",
                         Now,
                         emergency,
                         [{pid, self()}],
@@ -548,7 +548,7 @@ basic_test_() ->
       },
       {"pterm absence test",
          ?_assertEqual(<<"Pterm is: nothing">>,
-            iolist_to_binary(format(lager_msg:new("Message",
+            iolist_to_binary(format(rumMsg:new("Message",
                Now,
                emergency,
                [{pid, self()}],
@@ -557,7 +557,7 @@ basic_test_() ->
       },
       {"node formatting basic",
          begin
-            [N, "foo"] = format(lager_msg:new("Message",
+            [N, "foo"] = format(rumMsg:new("Message",
                Now,
                info,
                [{pid, self()}],

src/misc/lager_crash_log.erl → src/misc/rumCrashLog.erl

@@ -31,7 +31,7 @@
 %% documented in the README. To control the number of rotated files to be
 %% retained, use `crash_log_count'.
 
--module(lager_crash_log).
+-module(rumCrashLog).
 
 -include("rum.hrl").
 
@@ -137,7 +137,7 @@ limited_fmt(Fmt, Args, FmtMaxBytes) ->
    eRum:safe_format(Fmt, Args, FmtMaxBytes).
 
 limited_str(Term, FmtMaxBytes) ->
-   {Str, _} = lager_trunc_io:print(Term, FmtMaxBytes),
+   {Str, _} = rumTruncIo:print(Term, FmtMaxBytes),
    Str.
 
 other_node_suffix(Pid) when node(Pid) =/= node() ->
@@ -178,12 +178,12 @@ sasl_limited_str(supervisor_report, Report, FmtMaxBytes) ->
    Offender = rumStdlib:sup_get(offender, Report),
    FmtString = "     Supervisor: ~p~n     Context:    ~p~n     Reason:     "
    "~s~n     Offender:   ~s~n~n",
-   {ReasonStr, _} = lager_trunc_io:print(Reason, FmtMaxBytes),
-   {OffenderStr, _} = lager_trunc_io:print(Offender, FmtMaxBytes),
+   {ReasonStr, _} = rumTruncIo:print(Reason, FmtMaxBytes),
+   {OffenderStr, _} = rumTruncIo:print(Offender, FmtMaxBytes),
    io_lib:format(FmtString, [Name, Context, ReasonStr, OffenderStr]);
 sasl_limited_str(progress, Report, FmtMaxBytes) ->
    [begin
-       {Str, _} = lager_trunc_io:print(Data, FmtMaxBytes),
+       {Str, _} = rumTruncIo:print(Data, FmtMaxBytes),
        io_lib:format("    ~16w: ~s~n", [Tag, Str])
     end || {Tag, Data} <- Report];
 sasl_limited_str(crash_report, Report, FmtMaxBytes) ->
@@ -192,16 +192,17 @@ sasl_limited_str(crash_report, Report, FmtMaxBytes) ->
 do_log({log, Event}, #state{name = Name, fd = FD, inode = Inode, ctime = Ctime, flap = Flap,
    fmtmaxbytes = FmtMaxBytes, size = RotSize, count = Count, rotator = Rotator} = State) ->
    %% borrowed from riak_err
-   {ReportStr, Pid, MsgStr, _ErrorP} = case Event of
-                                          {error, _GL, {Pid1, Fmt, Args}} ->
-                                             {"ERROR REPORT", Pid1, limited_fmt(Fmt, Args, FmtMaxBytes), true};
-                                          {error_report, _GL, {Pid1, std_error, Rep}} ->
-                                             {"ERROR REPORT", Pid1, limited_str(Rep, FmtMaxBytes) ++ "\n", true};
-                                          {error_report, _GL, Other} ->
-                                             perhaps_a_sasl_report(error_report, Other, FmtMaxBytes);
-                                          _ ->
-                                             {ignore, ignore, ignore, false}
-                                       end,
+   {ReportStr, Pid, MsgStr, _ErrorP} =
+      case Event of
+         {error, _GL, {Pid1, Fmt, Args}} ->
+            {"ERROR REPORT", Pid1, limited_fmt(Fmt, Args, FmtMaxBytes), true};
+         {error_report, _GL, {Pid1, std_error, Rep}} ->
+            {"ERROR REPORT", Pid1, limited_str(Rep, FmtMaxBytes) ++ "\n", true};
+         {error_report, _GL, Other} ->
+            perhaps_a_sasl_report(error_report, Other, FmtMaxBytes);
+         _ ->
+            {ignore, ignore, ignore, false}
+      end,
    if ReportStr == ignore ->
       {ok, State};
       true ->

src/misc/error_logger_lager_h.erl → src/misc/rumErrLoggerH.erl

@@ -21,7 +21,7 @@
 
 %% @private
 
--module(error_logger_lager_h).
+-module(rumErrLoggerH).
 
 -include("rum.hrl").
 
@@ -178,46 +178,48 @@ eval_gl(Event, State) ->
    log_event(Event, State).
 
 log_event(Event, #state{sink = Sink} = State) ->
-   DidLog = case Event of
-               {error, _GL, {Pid, Fmt, Args}} ->
-                  FormatRaw = State#state.raw,
-                  case {FormatRaw, Fmt} of
-                     {false, "** Generic server " ++ _} ->
-                        %% gen_server terminate
-                        {Reason, Name} = case Args of
-                                            [N, _Msg, _State, R] ->
-                                               {R, N};
-                                            [N, _Msg, _State, R, _Client] ->
-                                               %% OTP 20 crash reports where the client pid is dead don't include the stacktrace
-                                               {R, N};
-                                            [N, _Msg, _State, R, _Client, _Stacktrace] ->
-                                               %% OTP 20 crash reports contain the pid of the client and stacktrace
-                                               %% TODO do something with them
-                                               {R, N}
-                                         end,
-                        ?CRASH_LOG(Event),
-                        {Md, Formatted} = format_reason_md(Reason),
-                        ?LOGFMT(Sink, error, [{pid, Pid}, {name, Name} | Md], "gen_server ~w terminated with reason: ~s",
-                           [Name, Formatted]);
+   DidLog =
+      case Event of
+         {error, _GL, {Pid, Fmt, Args}} ->
+            FormatRaw = State#state.raw,
+            case {FormatRaw, Fmt} of
+               {false, "** Generic server " ++ _} ->
+                  %% gen_server terminate
+                  {Reason, Name} = case Args of
+                                      [N, _Msg, _State, R] ->
+                                         {R, N};
+                                      [N, _Msg, _State, R, _Client] ->
+                                         %% OTP 20 crash reports where the client pid is dead don't include the stacktrace
+                                         {R, N};
+                                      [N, _Msg, _State, R, _Client, _Stacktrace] ->
+                                         %% OTP 20 crash reports contain the pid of the client and stacktrace
+                                         %% TODO do something with them
+                                         {R, N}
+                                   end,
+                  ?CRASH_LOG(Event),
+                  {Md, Formatted} = format_reason_md(Reason),
+                  ?LOGFMT(Sink, error, [{pid, Pid}, {name, Name} | Md], "gen_server ~w terminated with reason: ~s",
+                     [Name, Formatted]);
                      {false, "** State machine " ++ _} ->
                         %% Check if the terminated process is gen_fsm or gen_statem
                         %% since they generate the same exit message
-                        {Type, Name, StateName, Reason} = case Args of
-                                                             [TName, _Msg, TStateName, _StateData, TReason] ->
-                                                                {gen_fsm, TName, TStateName, TReason};
-                                                             %% Handle changed logging in gen_fsm stdlib-3.9 (TPid, ClientArgs)
-                                                             [TName, _Msg, TPid, TStateName, _StateData, TReason | _ClientArgs] when is_pid(TPid), is_atom(TStateName) ->
-                                                                {gen_fsm, TName, TStateName, TReason};
-                                                             %% Handle changed logging in gen_statem stdlib-3.9 (ClientArgs)
-                                                             [TName, _Msg, {TStateName, _StateData}, _ExitType, TReason, _CallbackMode, Stacktrace | _ClientArgs] ->
-                                                                {gen_statem, TName, TStateName, {TReason, Stacktrace}};
-                                                             %% Handle changed logging in gen_statem stdlib-3.9 (ClientArgs)
-                                                             [TName, {TStateName, _StateData}, _ExitType, TReason, _CallbackMode, Stacktrace | _ClientArgs] ->
-                                                                {gen_statem, TName, TStateName, {TReason, Stacktrace}};
-                                                             [TName, _Msg, [{TStateName, _StateData}], _ExitType, TReason, _CallbackMode, Stacktrace | _ClientArgs] ->
-                                                                %% sometimes gen_statem wraps its statename/data in a list for some reason???
-                                                                {gen_statem, TName, TStateName, {TReason, Stacktrace}}
-                                                          end,
+                        {Type, Name, StateName, Reason} =
+                           case Args of
+                              [TName, _Msg, TStateName, _StateData, TReason] ->
+                                 {gen_fsm, TName, TStateName, TReason};
+                              %% Handle changed logging in gen_fsm stdlib-3.9 (TPid, ClientArgs)
+                              [TName, _Msg, TPid, TStateName, _StateData, TReason | _ClientArgs] when is_pid(TPid), is_atom(TStateName) ->
+                                 {gen_fsm, TName, TStateName, TReason};
+                              %% Handle changed logging in gen_statem stdlib-3.9 (ClientArgs)
+                              [TName, _Msg, {TStateName, _StateData}, _ExitType, TReason, _CallbackMode, Stacktrace | _ClientArgs] ->
+                                 {gen_statem, TName, TStateName, {TReason, Stacktrace}};
+                              %% Handle changed logging in gen_statem stdlib-3.9 (ClientArgs)
+                              [TName, {TStateName, _StateData}, _ExitType, TReason, _CallbackMode, Stacktrace | _ClientArgs] ->
+                                 {gen_statem, TName, TStateName, {TReason, Stacktrace}};
+                              [TName, _Msg, [{TStateName, _StateData}], _ExitType, TReason, _CallbackMode, Stacktrace | _ClientArgs] ->
+                                 %% sometimes gen_statem wraps its statename/data in a list for some reason???
+                                 {gen_statem, TName, TStateName, {TReason, Stacktrace}}
+                           end,
                         {Md, Formatted} = format_reason_md(Reason),
                         ?CRASH_LOG(Event),
                         ?LOGFMT(Sink, error, [{pid, Pid}, {name, Name} | Md], "~s ~w in state ~w terminated with reason: ~s",
@@ -374,20 +376,22 @@ log_event(Event, #state{sink = Sink} = State) ->
    end.
 
 format_crash_report(Report, Neighbours) ->
-   Name = case get_value(registered_name, Report, []) of
-             [] ->
-                %% process_info(Pid, registered_name) returns [] for unregistered processes
-                get_value(pid, Report);
-             Atom -> Atom
-          end,
-   Md0 = case get_value(dictionary, Report, []) of
-            [] ->
-               %% process_info(Pid, registered_name) returns [] for unregistered processes
-               [];
-            Dict ->
-               %% pull the lager metadata out of the process dictionary, if we can
-               get_value('_lager_metadata', Dict, [])
-         end,
+   Name =
+      case get_value(registered_name, Report, []) of
+         [] ->
+            %% process_info(Pid, registered_name) returns [] for unregistered processes
+            get_value(pid, Report);
+         Atom -> Atom
+      end,
+   Md0 =
+      case get_value(dictionary, Report, []) of
+         [] ->
+            %% process_info(Pid, registered_name) returns [] for unregistered processes
+            [];
+         Dict ->
+            %% pull the lager metadata out of the process dictionary, if we can
+            get_value('_lager_metadata', Dict, [])
+      end,
 
    {Class, Reason, Trace} = get_value(error_info, Report),
    {Md, ReasonStr} = format_reason_md({Reason, Trace}),
@@ -499,7 +503,7 @@ format_reason_md({system_limit, [{M, F, _} | _] = Trace}) ->
               {ets, new} ->
                  "maximum number of ETS tables exceeded";
               _ ->
-                 {Str, _} = lager_trunc_io:print(Trace, 500),
+                 {Str, _} = rumTruncIo:print(Trace, 500),
                  Str
            end,
    {[{reason, system_limit}], ["system limit: ", Limit]};
@@ -548,7 +552,7 @@ format_reason_md({Reason, [{M, F, A, Props} | _]}) when is_atom(M), is_atom(F),
    {_, Formatted2} = format_mfa_md({M, F, A, Props}),
    {Md, [Formatted, " in ", Formatted2]};
 format_reason_md(Reason) ->
-   {Str, _} = lager_trunc_io:print(Reason, 500),
+   {Str, _} = rumTruncIo:print(Reason, 500),
    {[], Str}.
 
 %% backwards compatability shim
@@ -583,22 +587,22 @@ format_mfa_md(Other) ->
 format_args([], FmtAcc, ArgsAcc) ->
    {string:join(lists:reverse(FmtAcc), ", "), lists:reverse(ArgsAcc)};
 format_args([H | T], FmtAcc, ArgsAcc) ->
-   {Str, _} = lager_trunc_io:print(H, 100),
+   {Str, _} = rumTruncIo:print(H, 100),
    format_args(T, ["~s" | FmtAcc], [Str | ArgsAcc]).
 
 print_silly_list(L) when is_list(L) ->
    case rumStdlib:string_p(L) of
       true ->
-         lager_trunc_io:format("~s", [L], ?RumDefTruncation);
+         rumTruncIo:format("~s", [L], ?RumDefTruncation);
       _ ->
          print_silly_list(L, [], [])
    end;
 print_silly_list(L) ->
-   {Str, _} = lager_trunc_io:print(L, ?RumDefTruncation),
+   {Str, _} = rumTruncIo:print(L, ?RumDefTruncation),
    Str.
 
 print_silly_list([], Fmt, Acc) ->
-   lager_trunc_io:format(string:join(lists:reverse(Fmt), ", "),
+   rumTruncIo:format(string:join(lists:reverse(Fmt), ", "),
       lists:reverse(Acc), ?RumDefTruncation);
 print_silly_list([{K, V} | T], Fmt, Acc) ->
    print_silly_list(T, ["~p: ~p" | Fmt], [V, K | Acc]);
@@ -606,7 +610,7 @@ print_silly_list([H | T], Fmt, Acc) ->
    print_silly_list(T, ["~p" | Fmt], [H | Acc]).
 
 print_val(Val) ->
-   {Str, _} = lager_trunc_io:print(Val, 500),
+   {Str, _} = rumTruncIo:print(Val, 500),
    Str.
 
 

src/misc/lager_manager_killer.erl → src/misc/rumMgrKiller.erl

@@ -1,5 +1,5 @@
--module(lager_manager_killer).
--author("Sungjin Park <jinni.park@gmail.com>").
+-module(rumMgrKiller).
+
 -behavior(gen_event).
 
 -export([init/1, handle_event/2, handle_call/2, handle_info/2, terminate/2, code_change/3]).

src/misc/lager_msg.erl → src/misc/rumMsg.erl

@@ -1,4 +1,4 @@
--module(lager_msg).
+-module(rumMsg).
 
 -export([new/4, new/5]).
 -export([message/1]).
@@ -9,7 +9,7 @@
 -export([metadata/1]).
 -export([destinations/1]).
 
--record(lager_msg, {
+-record(rumMsg, {
    destinations :: list(),
    metadata :: [tuple()],
    severity :: eRum:log_level(),
@@ -18,47 +18,47 @@
    message :: list()
 }).
 
--opaque lager_msg() :: #lager_msg{}.
--export_type([lager_msg/0]).
+-opaque rumMsg() :: #rumMsg{}.
+-export_type([rumMsg/0]).
 
 %% create with provided timestamp, handy for testing mostly
--spec new(list(), erlang:timestamp(), eRum:log_level(), [tuple()], list()) -> lager_msg().
+-spec new(list(), erlang:timestamp(), eRum:log_level(), [tuple()], list()) -> rumMsg().
 new(Msg, Timestamp, Severity, Metadata, Destinations) ->
    {Date, Time} = rumUtil:format_time(rumUtil:maybe_utc(rumUtil:localtime_ms(Timestamp))),
-   #lager_msg{message = Msg, datetime = {Date, Time}, timestamp = Timestamp, severity = Severity,
+   #rumMsg{message = Msg, datetime = {Date, Time}, timestamp = Timestamp, severity = Severity,
       metadata = Metadata, destinations = Destinations}.
 
--spec new(list(), eRum:log_level(), [tuple()], list()) -> lager_msg().
+-spec new(list(), eRum:log_level(), [tuple()], list()) -> rumMsg().
 new(Msg, Severity, Metadata, Destinations) ->
    Now = os:timestamp(),
    new(Msg, Now, Severity, Metadata, Destinations).
 
--spec message(lager_msg()) -> list().
+-spec message(rumMsg()) -> list().
 message(Msg) ->
-   Msg#lager_msg.message.
+   Msg#rumMsg.message.
 
--spec timestamp(lager_msg()) -> erlang:timestamp().
+-spec timestamp(rumMsg()) -> erlang:timestamp().
 timestamp(Msg) ->
-   Msg#lager_msg.timestamp.
+   Msg#rumMsg.timestamp.
 
--spec datetime(lager_msg()) -> {string(), string()}.
+-spec datetime(rumMsg()) -> {string(), string()}.
 datetime(Msg) ->
-   Msg#lager_msg.datetime.
+   Msg#rumMsg.datetime.
 
--spec severity(lager_msg()) -> eRum:log_level().
+-spec severity(rumMsg()) -> eRum:log_level().
 severity(Msg) ->
-   Msg#lager_msg.severity.
+   Msg#rumMsg.severity.
 
--spec severity_as_int(lager_msg()) -> eRum:log_level_number().
+-spec severity_as_int(rumMsg()) -> eRum:log_level_number().
 severity_as_int(Msg) ->
-   rumUtil:level_to_num(Msg#lager_msg.severity).
+   rumUtil:level_to_num(Msg#rumMsg.severity).
 
--spec metadata(lager_msg()) -> [tuple()].
+-spec metadata(rumMsg()) -> [tuple()].
 metadata(Msg) ->
-   Msg#lager_msg.metadata.
+   Msg#rumMsg.metadata.
 
--spec destinations(lager_msg()) -> list().
+-spec destinations(rumMsg()) -> list().
 destinations(Msg) ->
-   Msg#lager_msg.destinations.
+   Msg#rumMsg.destinations.
 
 

src/misc/rumStdlib.erl

@@ -148,7 +148,7 @@ proc_lib_format([OwnReport, LinkReport], FmtMaxBytes) ->
 format_report(Rep, FmtMaxBytes) when is_list(Rep) ->
    format_rep(Rep, FmtMaxBytes);
 format_report(Rep, FmtMaxBytes) ->
-   {Str, _} = lager_trunc_io:print(Rep, FmtMaxBytes),
+   {Str, _} = rumTruncIo:print(Rep, FmtMaxBytes),
    io_lib:format("~p~n", [Str]).
 
 format_rep([{initial_call, InitialCall} | Rep], FmtMaxBytes) ->
@@ -180,12 +180,12 @@ format_mfa({M, F, Args} = StartF, FmtMaxBytes) ->
 
 pp_fun(FmtMaxBytes) ->
    fun(Term, _I) ->
-      {Str, _} = lager_trunc_io:print(Term, FmtMaxBytes),
+      {Str, _} = rumTruncIo:print(Term, FmtMaxBytes),
       io_lib:format("~s", [Str])
    end.
 
 format_tag(Tag, Data, FmtMaxBytes) ->
-   {Str, _} = lager_trunc_io:print(Data, FmtMaxBytes),
+   {Str, _} = rumTruncIo:print(Data, FmtMaxBytes),
    io_lib:format("    ~p: ~s~n", [Tag, Str]).
 
 %% From OTP stdlib's lib.erl ... These functions aren't exported.

src/misc/lager_trunc_io.erl → src/misc/rumTruncIo.erl

@@ -1,17 +1,3 @@
-%% ``The contents of this file are subject to the Erlang Public License,
-%% Version 1.1, (the "License"); you may not use this file except in
-%% compliance with the License. You should have received a copy of the
-%% Erlang Public License along with your Erlang distribution. If not, it can be
-%% retrieved via the world wide web at http://www.erlang.org/.
-%%
-%% Software distributed under the License is distributed on an "AS IS"
-%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
-%% the License for the specific language governing rights and limitations
-%% under the License.
-%%
-%% The Initial Developer of the Original Code is Corelatus AB.
-%% Portions created by Corelatus are Copyright 2003, Corelatus
-%% AB. All Rights Reserved.''
 %%
 %% @doc Module to print out terms for logging. Limits by length rather than depth.
 %%
@@ -30,7 +16,7 @@
 %% were added by Andrew Thompson `<andrew@basho.com>'. The module has been renamed
 %% to avoid conflicts with the vanilla module.
 
--module(lager_trunc_io).
+-module(rumTruncIo).
 -author('matthias@corelatus.se').
 %% And thanks to Chris Newcombe for a bug fix
 -export([format/3, format/4, print/2, print/3, fprint/2, fprint/3, safe/2]). % interface functions
@@ -146,39 +132,41 @@ print(Bin, Max, _Options) when is_binary(Bin), Max < 2 ->
    {"<<...>>", 7};
 print(Binary, Max, Options) when is_binary(Binary) ->
    B = binary_to_list(Binary, 1, lists:min([Max, byte_size(Binary)])),
-   {Res, Length} = case Options#print_options.lists_as_strings orelse
-      Options#print_options.force_strings of
-                      true ->
-                         Depth = Options#print_options.depth,
-                         MaxSize = (Depth - 1) * 4,
-                         %% check if we need to truncate based on depth
-                         In = case Depth > -1 andalso MaxSize < length(B) andalso
-                            not Options#print_options.force_strings of
-                                 true ->
-                                    string:substr(B, 1, MaxSize);
-                                 false -> B
-                              end,
-                         MaxLen = case Options#print_options.force_strings of
-                                     true ->
-                                        Max;
-                                     false ->
-                                        %% make room for the leading doublequote
-                                        Max - 1
-                                  end,
-                         try alist(In, MaxLen, Options) of
-                            {L0, Len0} ->
-                               case Options#print_options.force_strings of
-                                  false ->
-                                     case B /= In of
-                                        true ->
-                                           {[$", L0, "..."], Len0 + 4};
-                                        false ->
-                                           {[$" | L0], Len0 + 1}
-                                     end;
-                                  true ->
-                                     {L0, Len0}
-                               end
-                         catch
+   {Res, Length} =
+      case Options#print_options.lists_as_strings orelse Options#print_options.force_strings of
+         true ->
+            Depth = Options#print_options.depth,
+            MaxSize = (Depth - 1) * 4,
+            %% check if we need to truncate based on depth
+            In =
+               case Depth > -1 andalso MaxSize < length(B) andalso
+                  not Options#print_options.force_strings of
+                  true ->
+                     string:substr(B, 1, MaxSize);
+                  false -> B
+               end,
+            MaxLen =
+               case Options#print_options.force_strings of
+                  true ->
+                     Max;
+                  false ->
+                     %% make room for the leading doublequote
+                     Max - 1
+               end,
+            try alist(In, MaxLen, Options) of
+               {L0, Len0} ->
+                  case Options#print_options.force_strings of
+                     false ->
+                        case B /= In of
+                           true ->
+                              {[$", L0, "..."], Len0 + 4};
+                           false ->
+                              {[$" | L0], Len0 + 1}
+                        end;
+                     true ->
+                        {L0, Len0}
+                  end
+            catch
                             throw:{unprintable, C} ->
                                Index = string:chr(In, C),
                                case Index > 1 andalso Options#print_options.depth =< Index andalso
@@ -214,16 +202,17 @@ print({inline_bitstring, B}, _Max, _Options) when is_bitstring(B) ->
    SizeStr = integer_to_list(Size),
    {[ValueStr, $:, SizeStr], length(ValueStr) + length(SizeStr) + 1};
 print(BitString, Max, Options) when is_bitstring(BitString) ->
-   BL = case byte_size(BitString) > Max of
-           true ->
-              binary_to_list(BitString, 1, Max);
-           _ ->
-              R = erlang:bitstring_to_list(BitString),
-              {Bytes, [Bits]} = lists:splitwith(fun erlang:is_integer/1, R),
-              %% tag the trailing bits with a special tuple we catch when
-              %% list_body calls print again
-              Bytes ++ [{inline_bitstring, Bits}]
-        end,
+   BL =
+      case byte_size(BitString) > Max of
+         true ->
+            binary_to_list(BitString, 1, Max);
+         _ ->
+            R = erlang:bitstring_to_list(BitString),
+            {Bytes, [Bits]} = lists:splitwith(fun erlang:is_integer/1, R),
+            %% tag the trailing bits with a special tuple we catch when
+            %% list_body calls print again
+            Bytes ++ [{inline_bitstring, Bits}]
+      end,
    {X, Len0} = list_body(BL, Max - 4, dec_depth(Options), true),
    {["<<", X, ">>"], Len0 + 4};
 
@@ -300,10 +289,11 @@ list_body([H], Max, Options = #print_options{depth = 1}, _Tuple) ->
    print(H, Max, Options);
 list_body([H | _], Max, Options = #print_options{depth = 1}, Tuple) ->
    {List, Len} = print(H, Max - 4, Options),
-   Sep = case Tuple of
-            true -> $,;
-            false -> $|
-         end,
+   Sep =
+      case Tuple of
+         true -> $,;
+         false -> $|
+      end,
    {[List ++ [Sep | "..."]], Len + 4};
 list_body([H | T], Max, Options, Tuple) ->
    {List, Len} = print(H, Max, Options),
@@ -320,10 +310,11 @@ list_bodyc(_, _Max, #print_options{depth = 1}, false) -> {"|...", 4};
 list_bodyc([H | T], Max, #print_options{depth = Depth} = Options, Tuple) ->
    {List, Len} = print(H, Max, dec_depth(Options)),
    {Final, FLen} = list_bodyc(T, Max - Len - 1, dec_depth(Options), Tuple),
-   Sep = case Depth == 1 andalso not Tuple of
-            true -> $|;
-            _ -> $,
-         end,
+   Sep =
+      case Depth == 1 andalso not Tuple of
+         true -> $|;
+         _ -> $,
+      end,
    {[Sep, List | Final], FLen + Len + 1};
 list_bodyc(X, Max, Options, _Tuple) ->  %% improper list
    {List, Len} = print(X, Max - 1, Options),

src/misc/rumUtil.erl

@@ -439,18 +439,18 @@ check_trace(Attrs, {Filter, _Level, Dest}) when is_tuple(Filter) ->
          []
    end.
 
--spec is_loggable(lager_msg:lager_msg(), non_neg_integer()|{'mask', non_neg_integer()}, term()) -> boolean().
+-spec is_loggable(rumMsg:rumMsg(), non_neg_integer()|{'mask', non_neg_integer()}, term()) -> boolean().
 is_loggable(Msg, {mask, Mask}, MyName) ->
    %% using syslog style comparison flags
    %S = lager_msg:severity_as_int(Msg),
    %?debugFmt("comparing masks ~.2B and ~.2B -> ~p~n", [S, Mask, S band Mask]),
-   (lager_msg:severity_as_int(Msg) band Mask) /= 0 orelse
-      lists:member(MyName, lager_msg:destinations(Msg));
+   (rumMsg:severity_as_int(Msg) band Mask) /= 0 orelse
+      lists:member(MyName, rumMsg:destinations(Msg));
 is_loggable(Msg, SeverityThreshold, MyName) when is_atom(SeverityThreshold) ->
    is_loggable(Msg, level_to_num(SeverityThreshold), MyName);
 is_loggable(Msg, SeverityThreshold, MyName) when is_integer(SeverityThreshold) ->
-   lager_msg:severity_as_int(Msg) =< SeverityThreshold orelse
-      lists:member(MyName, lager_msg:destinations(Msg)).
+   rumMsg:severity_as_int(Msg) =< SeverityThreshold orelse
+      lists:member(MyName, rumMsg:destinations(Msg)).
 
 i2l(I) when I < 10 -> [$0, $0 + I];
 i2l(I) -> integer_to_list(I).
@@ -753,11 +753,11 @@ check_trace_test() ->
 
 is_loggable_test_() ->
    [
-      {"Loggable by severity only", ?_assert(is_loggable(lager_msg:new("", alert, [], []), 2, me))},
-      {"Not loggable by severity only", ?_assertNot(is_loggable(lager_msg:new("", critical, [], []), 1, me))},
-      {"Loggable by severity with destination", ?_assert(is_loggable(lager_msg:new("", alert, [], [you]), 2, me))},
-      {"Not loggable by severity with destination", ?_assertNot(is_loggable(lager_msg:new("", critical, [], [you]), 1, me))},
-      {"Loggable by destination overriding severity", ?_assert(is_loggable(lager_msg:new("", critical, [], [me]), 1, me))}
+      {"Loggable by severity only", ?_assert(is_loggable(rumMsg:new("", alert, [], []), 2, me))},
+      {"Not loggable by severity only", ?_assertNot(is_loggable(rumMsg:new("", critical, [], []), 1, me))},
+      {"Loggable by severity with destination", ?_assert(is_loggable(rumMsg:new("", alert, [], [you]), 2, me))},
+      {"Not loggable by severity with destination", ?_assertNot(is_loggable(rumMsg:new("", critical, [], [you]), 1, me))},
+      {"Loggable by destination overriding severity", ?_assert(is_loggable(rumMsg:new("", critical, [], [me]), 1, me))}
    ].
 
 format_time_test_() ->

src/test/lager_common_test_backend.erl

@@ -48,7 +48,7 @@ bounce(Level) ->
    ok = eRum:start(),
    %% we care more about getting all of our messages here than being
    %% careful with the amount of memory that we're using.
-   error_logger_lager_h:set_high_water(100000),
+   rumErrLoggerH:set_high_water(100000),
    ok.
 
 -spec(init(integer()|atom()|[term()]) -> {ok, #state{}} | {error, atom()}).

src/misc/lager_handler_watcher.erl → src/watcher/rumHandlerWatcherSrv.erl

@@ -19,7 +19,7 @@
 
 %% @private
 
--module(lager_handler_watcher).
+-module(rumHandlerWatcherSrv).
 
 -behaviour(gen_server).
 
@@ -80,7 +80,7 @@ handle_info({gen_event_EXIT, Module, {'EXIT', {kill_me, [_KillerHWM, KillerReins
 handle_info({gen_event_EXIT, Module, Reason}, #state{module = Module,
    config = Config, sink = Sink} = State) ->
    case eRum:log(error, self(), "Lager event handler ~p exited with reason ~s",
-      [Module, error_logger_lager_h:format_reason(Reason)]) of
+      [Module, rumErrLoggerH:format_reason(Reason)]) of
       ok ->
          install_handler(Sink, Module, Config);
       {error, _} ->
@@ -214,7 +214,7 @@ reinstall_handlers_after_killer_hwm_test_() ->
             eRum:trace_file("foo", [{foo, "bar"}], error),
             L = length(gen_event:which_handlers(lager_event)),
             try
-               lager_manager_killer:kill_me(),
+               rumMgrKiller:kill_me(),
                timer:sleep(6000),
                ?assertEqual(L, length(gen_event:which_handlers(lager_event))),
                file:delete("foo")

src/misc/lager_handler_watcher_sup.erl → src/watcher/rumHandlerWatcherSup.erl

@@ -18,7 +18,7 @@
 
 %% @private
 
--module(lager_handler_watcher_sup).
+-module(rumHandlerWatcherSup).
 
 -behaviour(supervisor).
 

test/lager_metadata_whitelist_test.erl

@@ -35,7 +35,7 @@ basic_test_() ->
       [{"Meta", fun() ->
          Whitelist = [meta0],
          ok = application:set_env(lager, metadata_whitelist, Whitelist),
-         Msg = lager_msg:new("Message", Now, error, [], []),
+         Msg = rumMsg:new("Message", Now, error, [], []),
          Expected = iolist_to_binary([Date, " ", Time, " [error]  Message\n"]),
          Got = iolist_to_binary(rumFormatter:format(Msg, [])),
          ?assertEqual(Expected, Got)
@@ -43,7 +43,7 @@ basic_test_() ->
          {"Meta1", fun() ->
             Whitelist = [meta1],
             ok = application:set_env(lager, metadata_whitelist, Whitelist),
-            Msg = lager_msg:new("Message", Now, error, [{meta1, "value1"}], []),
+            Msg = rumMsg:new("Message", Now, error, [{meta1, "value1"}], []),
             Expected = iolist_to_binary([Date, " ", Time, " [error]  meta1=value1 Message\n"]),
             Got = iolist_to_binary(rumFormatter:format(Msg, [])),
             ?assertEqual(Expected, Got)
@@ -51,7 +51,7 @@ basic_test_() ->
          {"Meta2", fun() ->
             Whitelist = [meta1, meta2],
             ok = application:set_env(lager, metadata_whitelist, Whitelist),
-            Msg = lager_msg:new("Message", Now, error, [{meta1, "value1"}, {meta2, 2}], []),
+            Msg = rumMsg:new("Message", Now, error, [{meta1, "value1"}, {meta2, 2}], []),
             Expected = iolist_to_binary([Date, " ", Time, " [error]  meta1=value1 meta2=2 Message\n"]),
             Got = iolist_to_binary(rumFormatter:format(Msg, [])),
             ?assertEqual(Expected, Got)
@@ -59,7 +59,7 @@ basic_test_() ->
          {"Meta3", fun() ->
             Whitelist = [meta1, meta2],
             ok = application:set_env(lager, metadata_whitelist, Whitelist),
-            Msg = lager_msg:new("Message", Now, error, [{meta1, "value1"}, {meta3, 3}], []),
+            Msg = rumMsg:new("Message", Now, error, [{meta1, "value1"}, {meta3, 3}], []),
             Expected = iolist_to_binary([Date, " ", Time, " [error]  meta1=value1 Message\n"]),
             Got = iolist_to_binary(rumFormatter:format(Msg, [])),
             ?assertEqual(Expected, Got)

test/lager_test_backend.erl

@@ -101,9 +101,9 @@ handle_event({log, Msg},
    case rumUtil:is_loggable(Msg, LogLevel, ?MODULE) of
       true ->
          {ok, State#state{buffer = Buffer ++
-         [{lager_msg:severity_as_int(Msg),
-            lager_msg:datetime(Msg),
-            lager_msg:message(Msg), lager_msg:metadata(Msg)}]}};
+         [{rumMsg:severity_as_int(Msg),
+            rumMsg:datetime(Msg),
+            rumMsg:message(Msg), rumMsg:metadata(Msg)}]}};
       _ ->
          {ok, State#state{ignored = Ignored ++ [Msg]}}
    end;
@@ -1874,7 +1874,7 @@ high_watermark_test_() ->
       [
          {"Nothing dropped when error_logger high watermark is undefined",
             fun() ->
-               ok = error_logger_lager_h:set_high_water(undefined),
+               ok = rumErrLoggerH:set_high_water(undefined),
                timer:sleep(100),
                produce_n_error_logger_msgs(10),
                timer:sleep(500),
@@ -1883,7 +1883,7 @@ high_watermark_test_() ->
          },
          {"Mostly dropped according to error_logger high watermark",
             fun() ->
-               ok = error_logger_lager_h:set_high_water(5),
+               ok = rumErrLoggerH:set_high_water(5),
                timer:sleep(100),
                produce_n_error_logger_msgs(50),
                timer:sleep(1000),
@@ -1892,7 +1892,7 @@ high_watermark_test_() ->
          },
          {"Non-notifications are not dropped",
             fun() ->
-               ok = error_logger_lager_h:set_high_water(2),
+               ok = rumErrLoggerH:set_high_water(2),
                timer:sleep(100),
                spawn(fun() -> produce_n_error_logger_msgs(300) end),
                timer:sleep(50),

test/trunc_io_eqc.erl

@@ -168,7 +168,7 @@ prop_format() ->
          FudgeLen = calculate_fudge(FmtArgs, 50),
          {FmtStr, Args} = build_fmt_args(FmtArgs),
          try
-            Str = lists:flatten(lager_trunc_io:format(FmtStr, Args, MaxLen)),
+            Str = lists:flatten(rumTruncIo:format(FmtStr, Args, MaxLen)),
             ?WHENFAIL(begin
                          io:format(user, "FmtStr:   ~p\n", [FmtStr]),
                          io:format(user, "Args:     ~p\n", [Args]),
@@ -199,7 +199,7 @@ prop_equivalence() ->
       begin
          {FmtStr, Args} = build_fmt_args(FmtArgs),
          Expected = lists:flatten(io_lib:format(FmtStr, Args)),
-         Actual = lists:flatten(lager_trunc_io:format(FmtStr, Args, 10485760)),
+         Actual = lists:flatten(rumTruncIo:format(FmtStr, Args, 10485760)),
          ?WHENFAIL(begin
                       io:format(user, "FmtStr:   ~p\n", [FmtStr]),
                       io:format(user, "Args:     ~p\n", [Args]),