diff --git a/include/lager.hrl b/include/lager.hrl deleted file mode 100644 index 22e5678..0000000 --- a/include/lager.hrl +++ /dev/null @@ -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{}. diff --git a/include/rum.hrl b/include/rum.hrl new file mode 100644 index 0000000..0a5f46a --- /dev/null +++ b/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{}. diff --git a/src/eRum.app.src b/src/eRum.app.src index 0459bed..64af43f 100644 --- a/src/eRum.app.src +++ b/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, []} - ]}. diff --git a/src/eRum_app.erl b/src/eRum_app.erl index 8ea067f..b5e94b9 100644 --- a/src/eRum_app.erl +++ b/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. diff --git a/src/eRum_sup.erl b/src/eRum_sup.erl index 2f68888..3ec12e4 100644 --- a/src/eRum_sup.erl +++ b/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 diff --git a/src/error_logger_lager_h.erl b/src/error_logger_lager_h.erl index b6ef5a9..72dcd19 100644 --- a/src/error_logger_lager_h.erl +++ b/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) -> diff --git a/src/lager.app.src b/src/lager.app.src deleted file mode 100644 index 52ca3c0..0000000 --- a/src/lager.app.src +++ /dev/null @@ -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"}]} - ]}. diff --git a/src/lager.erl b/src/lager.erl index 275bebc..335d0a9 100644 --- a/src/lager.erl +++ b/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. diff --git a/src/lager_app.erl b/src/lager_app.erl deleted file mode 100644 index be59289..0000000 --- a/src/lager_app.erl +++ /dev/null @@ -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. diff --git a/src/lager_backend_throttle.erl b/src/lager_backend_throttle.erl index 90b9c40..bb7319a 100644 --- a/src/lager_backend_throttle.erl +++ b/src/lager_backend_throttle.erl @@ -22,7 +22,7 @@ -module(lager_backend_throttle). --include("lager.hrl"). +-include("rum.hrl"). -behaviour(gen_event). diff --git a/src/lager_common_test_backend.erl b/src/lager_common_test_backend.erl index 0e03d6f..56cf772 100644 --- a/src/lager_common_test_backend.erl +++ b/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; diff --git a/src/lager_config.erl b/src/lager_config.erl index 646ab8a..15fc70b 100644 --- a/src/lager_config.erl +++ b/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 diff --git a/src/lager_console_backend.erl b/src/lager_console_backend.erl index 917f078..37ada6a 100644 --- a/src/lager_console_backend.erl +++ b/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 diff --git a/src/lager_crash_log.erl b/src/lager_crash_log.erl index c7de2b5..0a4264a 100644 --- a/src/lager_crash_log.erl +++ b/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), diff --git a/src/lager_default_formatter.erl b/src/lager_default_formatter.erl index fdabc81..e82a6d3 100644 --- a/src/lager_default_formatter.erl +++ b/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_() -> diff --git a/src/lager_file_backend.erl b/src/lager_file_backend.erl index 6b1ab17..c3a36c5 100644 --- a/src/lager_file_backend.erl +++ b/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}) -> diff --git a/src/lager_handler_watcher.erl b/src/lager_handler_watcher.erl index 7449557..dc36282 100644 --- a/src/lager_handler_watcher.erl +++ b/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"). diff --git a/src/lager_manager_killer.erl b/src/lager_manager_killer.erl index d9a5edb..0ebd2cd 100644 --- a/src/lager_manager_killer.erl +++ b/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(), diff --git a/src/lager_msg.erl b/src/lager_msg.erl index 6e69a8d..e7d7dac 100644 --- a/src/lager_msg.erl +++ b/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) -> diff --git a/src/lager_rotator_default.erl b/src/lager_rotator_default.erl index 738585f..7e89166 100644 --- a/src/lager_rotator_default.erl +++ b/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. diff --git a/src/lager_sup.erl b/src/lager_sup.erl deleted file mode 100644 index 97bfd00..0000000 --- a/src/lager_sup.erl +++ /dev/null @@ -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]}]. diff --git a/src/lager_transform.erl b/src/lager_transform.erl index 5c2134c..f430dad 100644 --- a/src/lager_transform.erl +++ b/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, diff --git a/src/lager_util.erl b/src/rumUtil.erl similarity index 93% rename from src/lager_util.erl rename to src/rumUtil.erl index 21e84b7..b193570 100644 --- a/src/lager_util.erl +++ b/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(), diff --git a/test/lager_crash_backend.erl b/test/lager_crash_backend.erl index b573a73..fe9d7b7 100644 --- a/test/lager_crash_backend.erl +++ b/test/lager_crash_backend.erl @@ -16,7 +16,7 @@ -module(lager_crash_backend). --include("lager.hrl"). +-include("rum.hrl"). -behaviour(gen_event). diff --git a/test/lager_metadata_whitelist_test.erl b/test/lager_metadata_whitelist_test.erl index e61661a..89bbcb6 100644 --- a/test/lager_metadata_whitelist_test.erl +++ b/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_() -> diff --git a/test/lager_rotate.erl b/test/lager_rotate.erl index 5c6c1e3..41facc8 100644 --- a/test/lager_rotate.erl +++ b/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) -> diff --git a/test/lager_slow_backend.erl b/test/lager_slow_backend.erl index e467c23..e37cfaa 100644 --- a/test/lager_slow_backend.erl +++ b/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}. diff --git a/test/lager_test_backend.erl b/test/lager_test_backend.erl index 94dd22e..b1968e7 100644 --- a/test/lager_test_backend.erl +++ b/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"], []), diff --git a/test/lager_test_function_transform.erl b/test/lager_test_function_transform.erl index e845fa6..d5bd0f4 100644 --- a/test/lager_test_function_transform.erl +++ b/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