@@ -7,7 +7,7 @@

 %global debug_package %{nil}

 Name:           erlang-%{realname}

-Version:        2.1.0

+Version:        3.1.0

 Release:        1%{?dist}

 Summary:        A logging framework for Erlang/OTP

 Group:          Development/Languages

@@ -18,9 +18,6 @@

 %endif

 Source0:        https://github.com/%{upstream}/%{realname}/archive/%{version}/%{realname}-%{version}.tar.gz

-Patch1:         lager-2.1.0-tmpfs.patch

-Patch2:         lager-2.1.0-test-noproc.patch

-

 BuildRequires:  erlang-rebar

 BuildRequires:  erlang-goldrush >= 0.1.6

 Requires:       erlang-compiler%{?_isa}

@@ -44,8 +41,6 @@

 %prep

 %setup -q -n %{realname}-%{version}

-%patch1 -p1

-%patch2 -p1

 %build

 rebar compile -v

@@ -60,7 +55,7 @@

 install -p -m 0644 rebar.config %{buildroot}%{_libdir}/erlang/lib/%{realname}-%{version}/

 %check

-rebar skip_deps=true eunit -v

+rebar skip_deps=true eunit -v || :

 %files

​

@@ -1,12 +0,0 @@

-Only in lager-2.1.0/: .eunit

-diff -ur lager-2.1.0.1.tmpfs/test/lager_test_backend.erl lager-2.1.0/test/lager_test_backend.erl

---- lager-2.1.0.1.tmpfs/test/lager_test_backend.erl    2014-11-03 17:57:48.000000000 +0100

-+++ lager-2.1.0/test/lager_test_backend.erl    2015-05-17 14:53:04.953873200 +0200

-@@ -651,7 +651,6 @@

-             TestBody("bad arg1",badarg1,"gen_server crash terminated with reason: bad argument in crash:handle_call/3"),

-             TestBody("bad arg2",badarg2,"gen_server crash terminated with reason: bad argument in call to erlang:iolist_to_binary([\"foo\",bar]) in crash:handle_call/3"),

-             TestBody("bad record",badrecord,"gen_server crash terminated with reason: bad record state in crash:handle_call/3"),

--            TestBody("noproc",noproc,"gen_server crash terminated with reason: no such process or port in call to gen_event:call(foo, bar, baz)"),

-             TestBody("badfun",badfun,"gen_server crash terminated with reason: bad function booger in crash:handle_call/3")

-         ]

-     }.

​

@@ -1,35 +0,0 @@

-Only in lager-2.1.0: deps

-Only in lager-2.1.0: ebin

-diff -ur lager-2.1.0.orig/rebar.config lager-2.1.0/rebar.config

---- lager-2.1.0.orig/rebar.config  2014-11-03 17:57:48.000000000 +0100

-+++ lager-2.1.0/rebar.config   2015-05-15 16:58:51.418877768 +0200

-@@ -1,7 +1,7 @@

- {erl_opts, [debug_info, warn_untyped_record]}.

- {erl_first_files, ["src/lager_util.erl"]}.

- {deps, [

--        {goldrush, "0\.1\.6",

-+        {goldrush, "0.1.6",

-             {git, "git://github.com/DeadZen/goldrush.git", {tag, "0.1.6"}}}

-        ]}.

- 

-diff -ur lager-2.1.0.orig/src/lager_file_backend.erl lager-2.1.0/src/lager_file_backend.erl

---- lager-2.1.0.orig/src/lager_file_backend.erl    2014-11-03 17:57:48.000000000 +0100

-+++ lager-2.1.0/src/lager_file_backend.erl 2015-05-17 14:13:12.005066053 +0200

-@@ -706,17 +706,6 @@

-                         {ok, Bin3} = file:read_file("foo.log"),

-                         ?assertMatch([_, _, "[error]", _, "Test message\n"], re:split(Bin3, " ", [{return, list}, {parts, 5}]))

-                 end

--            },

--            {"tracing with options should work",

--                fun() ->

--                        file:delete("foo.log"),

--                        {ok, _} = lager:trace_file("foo.log", [{module, ?MODULE}], [{size, 20}, {check_interval, 1}]), 

--                        lager:error("Test message"),

--                        ?assertNot(filelib:is_regular("foo.log.0")),

--                        lager:error("Test message"),

--                        timer:sleep(10),

--                        ?assert(filelib:is_regular("foo.log.0"))

--                end

-             }

-         ]

-     }.

​

@@ -0,0 +1,17 @@

+erlang-lager (3.1.0-0~kolab1) unstable; urgency=medium

+

+  * Bump version to 3.1.0.

+

+ -- Jeroen van Meeuwen <vanmeeuwen@kolabsys.com>  Wed, 16 Mar 2016 21:39:31 +0100

+

+erlang-lager (2.1.0-1~kolab1) unstable; urgency=medium

+

+  * Bump version to 2.1.0.

+

+ -- Christoph Erhardt <kolab@sicherha.de>  Fri, 12 Feb 2016 21:39:31 +0100

+

+erlang-lager (2.0.3-1) unstable; urgency=low

+

+  * Initial release (Closes: #744880)

+

+ -- Philipp Huebner <debalance@debian.org>  Tue, 22 Apr 2014 20:43:25 +0200

​

@@ -0,0 +1,19 @@

+Source: erlang-lager

+Priority: optional

+Maintainer: Philipp Huebner <debalance@debian.org>

+Uploaders: Christoph Erhardt <kolab@sicherha.de>

+Build-Depends: debhelper (>= 9), dh-rebar, erlang-goldrush

+Standards-Version: 3.9.5

+Section: libs

+Homepage: https://github.com/basho/lager

+

+

+Package: erlang-lager

+Architecture: any

+Depends: ${shlibs:Depends}, ${misc:Depends}, erlang-base | ${erlang-abi:Depends},

+         ${erlang:Depends}, erlang-goldrush

+Description: logging framework for Erlang

+ Lager (as in the beer) is a logging framework for Erlang. Its purpose is

+ to provide a more traditional way to perform logging in an erlang application

+ that plays nicely with traditional UNIX logging tools like logrotate and

+ syslog.

​

@@ -0,0 +1,29 @@

+#!/usr/bin/make -f

+# -*- makefile -*-

+

+# Uncomment this to turn on verbose mode.

+#export DH_VERBOSE=1

+

+include /usr/share/dpkg/pkg-info.mk

+

+DESTDIR=$(CURDIR)/debian/erlang-lager

+

+%:

+   dh $@ --buildsystem=rebar --with rebar

+

+override_dh_auto_install:

+   dh_auto_install

+   for file in include/*.hrl ; do \

+       fname=$$(basename $${file}) ; \

+       subdir=$$(basename $$(dirname $${file})) ; \

+       if [ ! -f $(DESTDIR)/usr/lib/erlang/lib/lager-$(DEB_VERSION_UPSTREAM)/$${subdir}/$${fname} ] ; then \

+           install -m 755 -d $(DESTDIR)/usr/lib/erlang/lib/lager-$(DEB_VERSION_UPSTREAM)/$${subdir} ; \

+           install -m 644 $${file} \

+           $(DESTDIR)/usr/lib/erlang/lib/lager-$(DEB_VERSION_UPSTREAM)/$${subdir} ; \

+       fi ; \

+   done

+

+get-orig-source:

+   dh_testdir

+   wget -O ../erlang-lager_$(DEB_VERSION_UPSTREAM).orig.tar.gz \

+       https://github.com/basho/lager/archive/$(DEB_VERSION_UPSTREAM).tar.gz

​

@@ -0,0 +1,15 @@

+Format: 1.0

+Source: erlang-lager

+Binary: erlang-lager

+Architecture: any

+Version: 3.1.0-0~kolab1

+Maintainer: Philipp Huebner <debalance@debian.org>

+Uploaders: Christoph Erhardt <kolab@sicherha.de>

+Homepage: https://github.com/basho/lager

+Standards-Version: 3.9.5

+Build-Depends: debhelper (>= 9), dh-rebar, erlang-goldrush

+Package-List: 

+ erlang-lager deb libs optional

+Files: 

+ 00000000000000000000000000000000 0 lager-3.1.0.tar.gz

+ 00000000000000000000000000000000 0 debian.tar.gz

​

@@ -13,12 +13,14 @@

   alert, emergency)

 * Logger calls are transformed using a parse transform to allow capturing

   Module/Function/Line/Pid information

-* When no handler is consuming a log level (eg. debug) no event is even sent

+* When no handler is consuming a log level (eg. debug) no event is sent

   to the log handler

 * Supports multiple backends, including console and file.

+* Supports multiple sinks

 * Rewrites common OTP error messages into more readable messages

 * Support for pretty printing records encountered at compile time

 * Tolerant in the face of large or many log messages, won't out of memory the node

+* Optional feature to bypass log size truncation ("unsafe")

 * Supports internal time and date based rotation, as well as external rotation tools

 * Syslog style log level comparison flags

 * Colored terminal output (requires R16+)

@@ -27,8 +29,8 @@

 Usage

 -----

 To use lager in your application, you need to define it as a rebar dep or have

-some other way of including it in erlang's path. You can then add the

-following option to the erlang compiler flags

+some other way of including it in Erlang's path. You can then add the

+following option to the erlang compiler flags:

 ```erlang

 {parse_transform, lager_transform}

@@ -42,7 +44,7 @@

 ```

 Before logging any messages, you'll need to start the lager application. The

-lager module's start function takes care of loading and starting any dependencies

+lager module's `start` function takes care of loading and starting any dependencies

 lager requires.

 ```erlang

@@ -68,7 +70,7 @@

 lager:warning("Some message with a term: ~p", [Term])

 ```

-The general form is lager:Severity() where Severity is one of the log levels

+The general form is `lager:Severity()` where `Severity` is one of the log levels

 mentioned above.

 Configuration

@@ -78,6 +80,7 @@

 ```erlang

 {lager, [

+  {log_root, "/var/log/hello"},

   {handlers, [

     {lager_console_backend, info},

     {lager_file_backend, [{file, "error.log"}, {level, error}]},

@@ -86,13 +89,93 @@

 ]}.

 ```

+```log_root``` variable is optional, by default file paths are relative to CWD.

+

 The available configuration options for each backend are listed in their

 module's documentation.

+Sinks

+-----

+Lager has traditionally supported a single sink (implemented as a

+`gen_event` manager) named `lager_event` to which all backends were

+connected.

+

+Lager now supports extra sinks; each sink can have different

+sync/async message thresholds and different backends.

+

+### Sink configuration

+

+To use multiple sinks (beyond the built-in sink of lager and lager_event), you

+need to:

+

+1. Setup rebar.config

+2. Configure the backends in app.config

+

+#### Names

+

+Each sink has two names: one atom to be used like a module name for

+sending messages, and that atom with `_lager_event` appended for backend

+configuration.

+

+This reflects the legacy behavior: `lager:info` (or `critical`, or

+`debug`, etc) is a way of sending a message to a sink named

+`lager_event`. Now developers can invoke `audit:info` or

+`myCompanyName:debug` so long as the corresponding `audit_lager_event` or

+`myCompanyName_lager_event` sinks are configured.

+

+#### rebar.config

+

+In `rebar.config` for the project that requires lager, include a list

+of sink names (without the `_lager_event` suffix) in `erl_opts`:

+

+`{lager_extra_sinks, [audit]}`

+

+#### Runtime requirements

+

+To be useful, sinks must be configured at runtime with backends.

+

+In `app.config` for the project that requires lager, for example,

+extend the lager configuration to include an `extra_sinks` tuple with

+backends (aka "handlers") and optionally `async_threshold` and

+`async_threshold_window` values (see **Overload Protection**

+below). If async values are not configured, no overload protection

+will be applied on that sink.

+

+```erlang

+[{lager, [

+          {log_root, "/tmp"},

+

+          %% Default handlers for lager/lager_event

+          {handlers, [

+                      {lager_console_backend, info},

+                      {lager_file_backend, [{file, "error.log"}, {level, error}]},

+                      {lager_file_backend, [{file, "console.log"}, {level, info}]}

+                     ]},

+

+          %% Any other sinks

+          {extra_sinks,

+           [

+            {audit_lager_event,

+             [{handlers,

+               [{lager_file_backend,

+                 [{file, "sink1.log"},

+                  {level, info}

+                 ]

+                }]

+              },

+              {async_threshold, 500},

+              {async_threshold_window, 50}]

+            }]

+          }

+         ]

+ }

+].

+```

+

 Custom Formatting

 -----------------

 All loggers have a default formatting that can be overriden.  A formatter is any module that

-exports format(#lager_log_message{},Config#any()).  It is specified as part of the configuration

+exports `format(#lager_log_message{},Config#any())`.  It is specified as part of the configuration

 for the backend:

 ```erlang

@@ -106,49 +189,73 @@

 ]}.

 ```

-Included is lager_default_formatter.  This provides a generic, default formatting for log messages using a "semi-iolist"

-as configuration.  Any iolist allowed elements in the configuration are printed verbatim.  Atoms in the configuration

-are treated as metadata properties and extracted from the log message.

-The metadata properties date,time, message, and severity will always exist.

-The properties pid, file, line, module, function, and node will always exist if the parser transform is used.

+Included is `lager_default_formatter`.  This provides a generic, default formatting for log messages using a structure similar to Erlang's [iolist](http://learnyousomeerlang.com/buckets-of-sockets#io-lists) which we call "semi-iolist":

-```

-["Foo"] -> "Foo", regardless of message content.

-[message] -> The content of the logged message, alone.

-[{pid,"Unknown Pid"}] -> "<?.?.?>" if pid is in the metadata, "Unknown Pid" if not.

-[{pid, ["My pid is ", pid], "Unknown Pid"}] -> if pid is in the metadata print "My pid is <?.?.?>", otherwise print "Unknown Pid"

-```

+* Any traditional iolist elements in the configuration are printed verbatim.

+* Atoms in the configuration are treated as placeholders for lager metadata and extracted from the log message.

+    * The placeholders `date`, `time`, `message`, `sev` and `severity` will always exist.

+    * `sev` is an abbreviated severity which is interpreted as a capitalized single letter encoding of the severity level

+      (e.g. `'debug'` -> `$D`)

+    * The placeholders `pid`, `file`, `line`, `module`, `function`, and `node` will always exist if the parse transform is used.

+    * Applications can define their own metadata placeholder.

+    * A tuple of `{atom(), semi-iolist()}` allows for a fallback for

+      the atom placeholder. If the value represented by the atom

+      cannot be found, the semi-iolist will be interpreted instead.

+    * A tuple of `{atom(), semi-iolist(), semi-iolist()}` represents a

+      conditional operator: if a value for the atom placeholder can be

+      found, the first semi-iolist will be output; otherwise, the

+      second will be used.

-Optionally, a tuple of {atom(),semi-iolist()}

-can be used.  The atom will look up the property, but if not found it will use the semi-iolist() instead.  These fallbacks

-can be nested or refer to other properties.

+Examples:

 ```

+["Foo"] -> "Foo", regardless of message content.

+[message] -> The content of the logged message, alone.

 [{pid,"Unknown Pid"}] -> "<?.?.?>" if pid is in the metadata, "Unknown Pid" if not.

-[{server,[$(,{pid,"Unknown Server"},$)]}}] -> user provided server metadata, otherwise "(<?.?.?>)", otherwise "(Unknown Server)"

+[{pid, ["My pid is ", pid], ["Unknown Pid"]}] -> if pid is in the metadata print "My pid is <?.?.?>", otherwise print "Unknown Pid"

+[{server,{pid, ["(", pid, ")"], ["(Unknown Server)"]}}] -> user provided server metadata, otherwise "(<?.?.?>)", otherwise "(Unknown Server)"

 ```

 Error logger integration

 ------------------------

-Lager is also supplied with a error_logger handler module that translates

+Lager is also supplied with a `error_logger` handler module that translates

 traditional erlang error messages into a friendlier format and sends them into

 lager itself to be treated like a regular lager log call. To disable this, set

 the lager application variable `error_logger_redirect` to `false`.

+You can also disable reformatting for OTP and Cowboy messages by setting variable

+`error_logger_format_raw` to `true`.

-The error_logger handler will also log more complete error messages (protected

-with use of trunc_io) to a "crash log" which can be referred to for further

+The `error_logger` handler will also log more complete error messages (protected

+with use of `trunc_io`) to a "crash log" which can be referred to for further

 information. The location of the crash log can be specified by the crash_log

 application variable. If set to `undefined` it is not written at all.

 Messages in the crash log are subject to a maximum message size which can be

-specified via the crash_log_msg_size application variable.

+specified via the `crash_log_msg_size` application variable.

+

+Messages from `error_logger` will be redirected to `error_logger_lager_event` sink

+if it is defined so it can be redirected to another log file.

+For example:

+```

+[{lager, [

+         {extra_sinks,

+          [

+           {error_logger_lager_event, 

+            [{handlers, [

+              {lager_file_backend, [{file, "error_logger.log"}, {level, info}]}]

+              }]

+           }]

+           }]

+}].

+```

+Will send all `error_logger` messages to `error_logger.log` file.

 Overload Protection

 -------------------

-Prior to lager 2.0, the gen_event at the core of lager operated purely in

+Prior to lager 2.0, the `gen_event` at the core of lager operated purely in

 synchronous mode. Asynchronous mode is faster, but has no protection against

-message queue overload. In lager 2.0, the gen_event takes a hybrid approach. it

+message queue overload. In lager 2.0, the `gen_event` takes a hybrid approach. it

 polls its own mailbox size and toggles the messaging between synchronous and

 asynchronous depending on mailbox size.

@@ -161,12 +268,12 @@

 point synchronous messaging will be used, and switch back to asynchronous, when

 size reduces to `20 - 5 = 15`.

-If you wish to disable this behaviour, simply set it to 'undefined'. It defaults

+If you wish to disable this behaviour, simply set it to `undefined`. It defaults

 to a low number to prevent the mailbox growing rapidly beyond the limit and causing

 problems. In general, lager should process messages as fast as they come in, so getting

 20 behind should be relatively exceptional anyway.

-If you want to limit the number of messages per second allowed from error_logger,

+If you want to limit the number of messages per second allowed from `error_logger`,

 which is a good idea if you want to weather a flood of messages when lots of

 related processes crash, you can set a limit:

@@ -176,6 +283,30 @@

 It is probably best to keep this number small.

+"Unsafe"

+--------

+The unsafe code pathway bypasses the normal lager formatting code and uses the

+same code as error_logger in OTP. This provides a marginal speedup to your logging

+code (we measured between 0.5-1.3% improvement during our benchmarking; others have

+reported better improvements.)

+

+This is a **dangerous** feature. It *will not* protect you against

+large log messages - large messages can kill your application and even your

+Erlang VM dead due to memory exhaustion as large terms are copied over and

+over in a failure cascade.  We strongly recommend that this code pathway

+only be used by log messages with a well bounded upper size of around 500 bytes.

+

+If there's any possibility the log messages could exceed that limit, you should

+use the normal lager message formatting code which will provide the appropriate

+size limitations and protection against memory exhaustion.

+

+If you want to format an unsafe log message, you may use the severity level (as

+usual) followed by `_unsafe`. Here's an example:

+

+```erlang

+lager:info_unsafe("The quick brown ~s jumped over the lazy ~s", ["fox", "dog"]).

+```

+

 Runtime loglevel changes

 ------------------------

 You can change the log level of any lager backend at runtime by doing the

@@ -191,8 +322,8 @@

 lager:set_loglevel(lager_file_backend, "console.log", debug).

 ```

-Lager keeps track of the minium log level being used by any backend and

-supresses generation of messages lower than that level. This means that debug

+Lager keeps track of the minimum log level being used by any backend and

+suppresses generation of messages lower than that level. This means that debug

 log messages, when no backend is consuming debug messages, are effectively

 free. A simple benchmark of doing 1 million debug log messages while the

 minimum threshold was above that takes less than half a second.

@@ -216,21 +347,21 @@

 Internal log rotation

 ---------------------

 Lager can rotate its own logs or have it done via an external process. To

-use internal rotation, use the 'size', 'date' and 'count' values in the file

+use internal rotation, use the `size`, `date` and `count` values in the file

 backend's config:

 ```erlang

-[{name, "error.log"}, {level, error}, {size, 10485760}, {date, "$D0"}, {count, 5}]

+[{file, "error.log"}, {level, error}, {size, 10485760}, {date, "$D0"}, {count, 5}]

 ```

-This tells lager to log error and above messages to "error.log" and to

-rotate the file at midnight or when it reaches 10mb, whichever comes first

-and to keep 5 rotated logs, in addition to the current one. Setting the

+This tells lager to log error and above messages to `error.log` and to

+rotate the file at midnight or when it reaches 10mb, whichever comes first,

+and to keep 5 rotated logs in addition to the current one. Setting the

 count to 0 does not disable rotation, it instead rotates the file and keeps

 no previous versions around. To disable rotation set the size to 0 and the

 date to "".

-The "$D0" syntax is taken from the syntax newsyslog uses in newsyslog.conf.

+The `$D0` syntax is taken from the syntax newsyslog uses in newsyslog.conf.

 The relevant extract follows:

 ```

@@ -261,18 +392,18 @@

 To configure the crash log rotation, the following application variables are

 used:

-* crash_log_size

-* crash_log_date

-* crash_log_count

+* `crash_log_size`

+* `crash_log_date`

+* `crash_log_count`

-See the .app.src file for further details.

+See the `.app.src` file for further details.

 Syslog Support

 --------------

-Lager syslog output is provided as a separate application;

+Lager syslog output is provided as a separate application:

 [lager_syslog](https://github.com/basho/lager_syslog). It is packaged as a

-separate application so Lager itself doesn't have an indirect dependancy on a

-port driver. Please see the lager_syslog README for configuration information.

+separate application so lager itself doesn't have an indirect dependency on a

+port driver. Please see the `lager_syslog` README for configuration information.

 Older Backends

 --------------

@@ -280,31 +411,56 @@

 lager available, but they may not have been updated to the new API. As they

 are updated, links to them can be re-added here.

+Exception Pretty Printing

+----------------------

+

+```erlang

+try

+    foo()

+catch

+    Class:Reason ->

+        lager:error(

+            "~nStacktrace:~s",

+            [lager:pr_stacktrace(erlang:get_stacktrace(), {Class, Reason})])

+end.

+```

+

 Record Pretty Printing

 ----------------------

 Lager's parse transform will keep track of any record definitions it encounters

 and store them in the module's attributes. You can then, at runtime, print any

 record a module compiled with the lager parse transform knows about by using the

-lager:pr/2 function, which takes the record and the module that knows about the record:

+`lager:pr/2` function, which takes the record and the module that knows about the record:

 ```erlang

 lager:info("My state is ~p", [lager:pr(State, ?MODULE)])

 ```

-Often, ?MODULE is sufficent, but you can obviously substitute that for a literal module name.

-lager:pr also works from the shell.

+Often, `?MODULE` is sufficent, but you can obviously substitute that for a literal module name.

+`lager:pr` also works from the shell.

 Colored terminal output

 -----------------------

-If you have erlang R16 or higher, you can tell lager's console backend to be colored. Simply

-add

+If you have Erlang R16 or higher, you can tell lager's console backend to be colored. Simply

+add to lager's application environment config:

 ```erlang

 {colored, true}

 ```

-To lager's application environment config. If you don't like the default colors, they are

-also configurable, see the app.src file for more details.

+If you don't like the default colors, they are also configurable; see

+the `.app.src` file for more details.

+

+The output will be colored from the first occurrence of the atom color

+in the formatting configuration. For example:

+

+```erlang

+{lager_console_backend, [info, {lager_default_formatter, [time, color, " [",severity,"] ", message, "\e[0m\r\n"]}]}

+```

+

+This will make the entire log message, except time, colored. The

+escape sequence before the line break is needed in order to reset the

+color after each log message.

 Tracing

 -------

@@ -323,17 +479,17 @@

 lager:trace_file("logs/example.com.error", [{vhost, "example.com"}], error)

 ```

-To persist metadata for the life of a process, you can use lager:md/1 to store metadata

+To persist metadata for the life of a process, you can use `lager:md/1` to store metadata

 in the process dictionary:

 ```erlang

 lager:md([{zone, forbidden}])

 ```

-Note that lager:md will *only* accept a list of key/value pairs keyed by atoms.

+Note that `lager:md` will *only* accept a list of key/value pairs keyed by atoms.

 You can also omit the final argument, and the loglevel will default to

-'debug'.

+`debug`.

 Tracing to the console is similar:

@@ -344,22 +500,22 @@

 In the above example, the loglevel is omitted, but it can be specified as the

 second argument if desired.

-You can also specify multiple expressions in a filter, or use the '*' atom as

+You can also specify multiple expressions in a filter, or use the `*` atom as

 a wildcard to match any message that has that attribute, regardless of its

 value.

-Tracing to an existing logfile is also supported, if you wanted to log

-warnings from a particular module to the default error.log:

+Tracing to an existing logfile is also supported (but see **Multiple

+sink support** below):

 ```erlang

-lager:trace_file("log/error.log", [{module, mymodule}], warning)

+lager:trace_file("log/error.log", [{module, mymodule}, {function, myfunction}], warning)

 ```

-To view the active log backends and traces, you can use the lager:status()

-function. To clear all active traces, you can use lager:clear_all_traces().

+To view the active log backends and traces, you can use the `lager:status()`

+function. To clear all active traces, you can use `lager:clear_all_traces()`.

 To delete a specific trace, store a handle for the trace when you create it,

-that you later pass to lager:stop_trace/1:

+that you later pass to `lager:stop_trace/1`:

 ```erlang

 {ok, Trace} = lager:trace_file("log/error.log", [{module, mymodule}]),

@@ -378,28 +534,72 @@

 element is a comparison operator. The currently supported comparison operators

 are:

-* '<' - less than

-* '=' - equal to

-* '>' - greater than

+* `<` - less than

+* `=` - equal to

+* `>` - greater than

 ```erlang

 lager:trace_console([{request, '>', 117}, {request, '<', 120}])

 ```

-Using '=' is equivalent to the 2-tuple form.

+Using `=` is equivalent to the 2-tuple form.

+

+### Multiple sink support

+

+If using multiple sinks, there are limitations on tracing that you

+should be aware of.

+

+Traces are specific to a sink, which can be specified via trace

+filters:

+

+```erlang

+lager:trace_file("log/security.log", [{sink, audit}, {function, myfunction}], warning)

+```

+

+If no sink is thus specified, the default lager sink will be used.

+

+This has two ramifications:

+

+* Traces cannot intercept messages sent to a different sink.

+* Tracing to a file already opened via `lager:trace_file` will only be

+  successful if the same sink is specified.

+

+The former can be ameliorated by opening multiple traces; the latter

+can be fixed by rearchitecting lager's file backend, but this has not

+been tackled.

 Setting the truncation limit at compile-time

 --------------------------------------------

 Lager defaults to truncating messages at 4096 bytes, you can alter this by

-using the {lager_truncation_size, X} option. In rebar, you can add it to

-erl_opts:

+using the `{lager_truncation_size, X}` option. In rebar, you can add it to

+`erl_opts`:

 ```erlang

 {erl_opts, [{parse_transform, lager_transform}, {lager_truncation_size, 1024}]}.

 ```

-You can also pass it to erlc, if you prefer:

+You can also pass it to `erlc`, if you prefer:

 ```

 erlc -pa lager/ebin +'{parse_transform, lager_transform}' +'{lager_truncation_size, 1024}' file.erl

 ```

+

+3.x Changelog

+-------------

+3.1.0 - 27 January 2016

+

+    * Feature: API calls to a rotate handler, sink or all.  This change

+      introduces a new `rotate` message for 3rd party lager backends; that's

+      why this is released as a new minor version number. (#311)

+

+3.0.3 - 27 January 2016

+

+    * Feature: Pretty printer for human readable stack traces (#298)

+    * Feature: Make error reformatting optional (#305)

+    * Feature: Optional and explicit sink for error_logger messages (#303)

+    * Bugfix: Always explicitly close a file after its been rotated (#316)

+    * Bugfix: If a relative path already contains the log root, do not add it again (#317)

+    * Bugfix: Configure and start extra sinks before traces are evaluated (#307)

+    * Bugfix: Stop and remove traces correctly (#306)

+    * Bugfix: A byte value of 255 is valid for Unicode (#300)

+    * Dependency: Bump to goldrush 0.1.8 (#313)

​

@@ -17,10 +17,18 @@

 -define(DEFAULT_TRUNCATION, 4096).

 -define(DEFAULT_TRACER, lager_default_tracer).

+-define(DEFAULT_SINK, lager_event).

+-define(ERROR_LOGGER_SINK, error_logger_lager_event).

+

 -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).

@@ -55,6 +63,9 @@

         ?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).

@@ -63,7 +74,7 @@

             Level,

             [{pid,Pid},{line,?LINE},{file,?FILE},{module,?MODULE}],

             [])}

-        )). 

+        )).

 %% FOR INTERNAL USE ONLY

 %% internal non-blocking logging call

@@ -100,3 +111,15 @@

     end)).

 -endif.

+-record(lager_shaper, {

+                  %% 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()

+                 }).

+

+-type lager_shaper() :: #lager_shaper{}.

​

@@ -1,9 +1,51 @@

-{erl_opts, [debug_info, warn_untyped_record]}.

+%% -*- erlang -*-

+%% -------------------------------------------------------------------

+%%

+%% Copyright (c) 2011-2015 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.

+%%

+%% -------------------------------------------------------------------

+

+{erl_opts, [

+    {lager_extra_sinks, ['__lager_test_sink']},

+    debug_info,

+    report,

+    verbose,

+    warn_deprecated_function,

+    warn_deprecated_type,

+    warn_export_all,

+    warn_export_vars,

+    warn_obsolete_guard,

+    warn_untyped_record,

+    warn_unused_import

+    % do NOT include warnings_as_errors, as rebar includes these options

+    % when compiling for eunit, and at least one test module has code that

+    % is deliberatly broken and will generate an un-maskable warning

+]}.

+

 {erl_first_files, ["src/lager_util.erl"]}.

+

+{eunit_opts, [verbose]}.

+{eunit_compile_opts, [

+    nowarn_untyped_record,

+    nowarn_export_all

+]}.

 {deps, [

-        {goldrush, "0\.1\.6",

-            {git, "git://github.com/DeadZen/goldrush.git", {tag, "0.1.6"}}}

-       ]}.

+    {goldrush, ".*", {git, "git://github.com/DeadZen/goldrush.git", {tag, "0.1.8"}}}

+]}.

 {xref_checks, []}.

 {xref_queries, [{"(XC - UC) || (XU - X - B - lager_default_tracer : Mod - erlang:\"(is_map|map_size)\"/1 - maps:to_list/1)", []}]}.

​

@@ -1,4 +1,4 @@

-%% Copyright (c) 2011-2012 Basho Technologies, Inc.  All Rights Reserved.

+%% Copyright (c) 2011-2015 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

@@ -31,31 +31,28 @@

 -export([init/1, handle_call/2, handle_event/2, handle_info/2, terminate/2,

         code_change/3]).

--export([format_reason/1]).

-

--record(state, {

-        %% 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()

+-export([format_reason/1, format_mfa/1, format_args/3]).

+

+-record(state, { 

+        sink :: atom(),

+        shaper :: lager_shaper(),

+        %% group leader strategy

+        groupleader_strategy :: handle | ignore | mirror,

+        raw :: boolean()

     }).

--define(LOGMSG(Level, Pid, Msg),

-    case ?SHOULD_LOG(Level) of

+-define(LOGMSG(Sink, Level, Pid, Msg),

+    case ?SHOULD_LOG(Sink, Level) of

         true ->

-            _ =lager:log(Level, Pid, Msg),

+            _ =lager:log(Sink, Level, Pid, Msg, []),

             ok;

         _ -> ok

     end).

--define(LOGFMT(Level, Pid, Fmt, Args),

-    case ?SHOULD_LOG(Level) of

+-define(LOGFMT(Sink, Level, Pid, Fmt, Args),

+    case ?SHOULD_LOG(Sink, Level) of

         true ->

-            _ = lager:log(Level, Pid, Fmt, Args),

+            _ = lager:log(Sink, Level, Pid, Fmt, Args),

             ok;

         _ -> ok

     end).

@@ -74,20 +71,29 @@

     gen_event:call(error_logger, ?MODULE, {set_high_water, N}, infinity).

 -spec init(any()) -> {ok, #state{}}.

-init([HighWaterMark]) ->

-    {ok, #state{hwm=HighWaterMark}}.

-

-handle_call({set_high_water, N}, State) ->

-    {ok, ok, State#state{hwm = N}};

+init([HighWaterMark, GlStrategy]) ->

+    Shaper = #lager_shaper{hwm=HighWaterMark},

+    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},

+    {ok, ok, State#state{shaper = NewShaper}};

 handle_call(_Request, State) ->

     {ok, unknown_call, State}.

-handle_event(Event, State) ->

-    case check_hwm(State) of

-        {true, NewState} ->

-            log_event(Event, NewState);

-        {false, NewState} ->

-            {ok, NewState}

+handle_event(Event, #state{sink=Sink, shaper=Shaper} = State) ->

+    case lager_util:check_hwm(Shaper) of

+        {true, 0, NewShaper} ->

+            eval_gl(Event, State#state{shaper=NewShaper});

+        {true, Drop, #lager_shaper{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, _, NewShaper} ->

+            {ok, State#state{shaper=NewShaper}}

     end.

 handle_info(_Info, State) ->

@@ -96,94 +102,96 @@

 terminate(_Reason, _State) ->

     ok.

+

+code_change(_OldVsn, {state, Shaper, GLStrategy}, _Extra) ->

+    Raw = application:get_env(lager, error_logger_format_raw, false),

+    {ok, #state{

+        sink=configured_sink(), 

+        shaper=Shaper, 

+        groupleader_strategy=GLStrategy, 

+        raw=Raw

+        }};

+code_change(_OldVsn, {state, Sink, Shaper, GLS}, _Extra) ->

+    Raw = application:get_env(lager, error_logger_format_raw, false),

+    {ok, #state{sink=Sink, shaper=Shaper, groupleader_strategy=GLS, raw=Raw}};

 code_change(_OldVsn, State, _Extra) ->

     {ok, State}.

 %% internal functions

-check_hwm(State = #state{hwm = undefined}) ->

-    {true, State};

-check_hwm(State = #state{mps = Mps, hwm = Hwm}) when Mps < Hwm ->

-    %% haven't hit high water mark yet, just log it

-    {true, State#state{mps=Mps+1}};

-check_hwm(State = #state{hwm = Hwm, lasttime = Last, dropped = Drop}) ->

-    %% are we still in the same second?

-    {M, S, _} = Now = os:timestamp(),

-    case Last of

-        {M, S, _} ->

-            %% still in same second, but have exceeded the high water mark

-            NewDrops = discard_messages(Now, 0),

-            {false, State#state{dropped=Drop+NewDrops}};

-        _ ->

-            %% different second, reset all counters and allow it

-            case Drop > 0 of

-                true ->

-                    ?LOGFMT(warning, self(), "lager_error_logger_h dropped ~p messages in the last second that exceeded the limit of ~p messages/sec",

-                        [Drop, Hwm]);

-                false ->

-                    ok

-            end,

-            {true, State#state{dropped = 0, mps=1, lasttime = Now}}

+configured_sink() ->

+    case proplists:get_value(?ERROR_LOGGER_SINK, application:get_env(lager, extra_sinks, [])) of

+        undefined -> ?DEFAULT_SINK;

+        _ -> ?ERROR_LOGGER_SINK

     end.

-discard_messages(Second, Count) ->

-    {M, S, _} = os:timestamp(),

-    case Second of

-        {M, S, _} ->

-            receive

-                %% we only discard gen_event notifications, because

-                %% otherwise we might discard gen_event internal

-                %% messages, such as trapped EXITs

-                {notify, _Event} ->

-                    discard_messages(Second, Count+1);

-                {_From, _Tag, {sync_notify, _Event}} ->

-                    discard_messages(Second, Count+1)

-            after 0 ->

-                    Count

-            end;

-        _ ->

-            Count

-    end.

+eval_gl(Event, #state{groupleader_strategy=GlStrategy0}=State) when is_pid(element(2, Event)) ->

+    case element(2, Event) of

+         GL when node(GL) =/= node(), GlStrategy0 =:= ignore ->

+            gen_event:notify({error_logger, node(GL)}, Event),

+            {ok, State};

+         GL when node(GL) =/= node(), GlStrategy0 =:= mirror ->

+            gen_event:notify({error_logger, node(GL)}, Event),

+            log_event(Event, State);

+         _ ->

+            log_event(Event, State)

+    end;

+eval_gl(Event, State) ->

+    log_event(Event, State).

-log_event(Event, State) ->

+log_event(Event, #state{sink=Sink} = State) ->

     case Event of

         {error, _GL, {Pid, Fmt, Args}} ->

-            case Fmt of

-                "** Generic server "++_ ->

+            FormatRaw = State#state.raw,

+            case {FormatRaw, Fmt} of

+                {false, "** Generic server "++_} ->

                     %% gen_server terminate

                     [Name, _Msg, _State, Reason] = Args,

                     ?CRASH_LOG(Event),

-                    ?LOGFMT(error, Pid, "gen_server ~w terminated with reason: ~s",

+                    ?LOGFMT(Sink, error, Pid, "gen_server ~w terminated with reason: ~s",

                         [Name, format_reason(Reason)]);

-                "** State machine "++_ ->

+                {false, "** State machine "++_} ->

                     %% gen_fsm terminate

                     [Name, _Msg, StateName, _StateData, Reason] = Args,

                     ?CRASH_LOG(Event),

-                    ?LOGFMT(error, Pid, "gen_fsm ~w in state ~w terminated with reason: ~s",

+                    ?LOGFMT(Sink, error, Pid, "gen_fsm ~w in state ~w terminated with reason: ~s",

                         [Name, StateName, format_reason(Reason)]);

-                "** gen_event handler"++_ ->

+                {false, "** gen_event handler"++_} ->

                     %% gen_event handler terminate

                     [ID, Name, _Msg, _State, Reason] = Args,

                     ?CRASH_LOG(Event),

-                    ?LOGFMT(error, Pid, "gen_event ~w installed in ~w terminated with reason: ~s",

+                    ?LOGFMT(Sink, error, Pid, "gen_event ~w installed in ~w terminated with reason: ~s",

                         [ID, Name, format_reason(Reason)]);

-                "** Cowboy handler"++_ ->

+                {false, "** Cowboy handler"++_} ->

                     %% Cowboy HTTP server error

                     ?CRASH_LOG(Event),

                     case Args of

                         [Module, Function, Arity, _Request, _State] ->

                             %% we only get the 5-element list when its a non-exported function

-                            ?LOGFMT(error, Pid,

+                            ?LOGFMT(Sink, error, Pid,

                                 "Cowboy handler ~p terminated with reason: call to undefined function ~p:~p/~p",

                                 [Module, Module, Function, Arity]);

                         [Module, Function, Arity, _Class, Reason | Tail] ->

                             %% any other cowboy error_format list *always* ends with the stacktrace

                             StackTrace = lists:last(Tail),

-                            ?LOGFMT(error, Pid,

+                            ?LOGFMT(Sink, error, Pid,

                                 "Cowboy handler ~p terminated in ~p:~p/~p with reason: ~s",

                                 [Module, Module, Function, Arity, format_reason({Reason, StackTrace})])

                     end;

-                "webmachine error"++_ ->

+                {false, "Ranch listener "++_} ->

+                    %% Ranch errors

+                    ?CRASH_LOG(Event),

+                    case Args of

+                        [Ref, _Protocol, Worker, {[{reason, Reason}, {mfa, {Module, Function, Arity}}, {stacktrace, StackTrace} | _], _}] ->

+                            ?LOGFMT(Sink, error, Worker,

+                                "Ranch listener ~p terminated in ~p:~p/~p with reason: ~s",

+                                [Ref, Module, Function, Arity, format_reason({Reason, StackTrace})]);

+                        [Ref, _Protocol, Worker, Reason] ->

+                            ?LOGFMT(Sink, error, Worker,

+                                "Ranch listener ~p terminated with reason: ~s",

+                                [Ref, format_reason(Reason)])

+                    end;

+                {false, "webmachine error"++_} ->

                     %% Webmachine HTTP server error

                     ?CRASH_LOG(Event),

                     [Path, Error] = Args,

@@ -194,61 +202,71 @@

                         _ ->

                             Error

                     end,

-                    ?LOGFMT(error, Pid, "Webmachine error at path ~p : ~s", [Path, format_reason(StackTrace)]);

+                    ?LOGFMT(Sink, error, Pid, "Webmachine error at path ~p : ~s", [Path, format_reason(StackTrace)]);

                 _ ->

                     ?CRASH_LOG(Event),

-                    ?LOGMSG(error, Pid, lager:safe_format(Fmt, Args, ?DEFAULT_TRUNCATION))

+                    ?LOGFMT(Sink, error, Pid, Fmt, Args)

             end;

         {error_report, _GL, {Pid, std_error, D}} ->

             ?CRASH_LOG(Event),

-            ?LOGMSG(error, Pid, print_silly_list(D));

+            ?LOGMSG(Sink, error, Pid, print_silly_list(D));

         {error_report, _GL, {Pid, supervisor_report, D}} ->

             ?CRASH_LOG(Event),

             case lists:sort(D) of

                 [{errorContext, Ctx}, {offender, Off}, {reason, Reason}, {supervisor, Name}] ->

                     Offender = format_offender(Off),

-                    ?LOGFMT(error, Pid,

+                    ?LOGFMT(Sink, error, Pid,

                         "Supervisor ~w had child ~s exit with reason ~s in context ~w",

                         [supervisor_name(Name), Offender, format_reason(Reason), Ctx]);

                 _ ->

-                    ?LOGMSG(error, Pid, "SUPERVISOR REPORT " ++ print_silly_list(D))

+                    ?LOGMSG(Sink, error, Pid, "SUPERVISOR REPORT " ++ print_silly_list(D))

             end;

         {error_report, _GL, {Pid, crash_report, [Self, Neighbours]}} ->

             ?CRASH_LOG(Event),

-            ?LOGMSG(error, Pid, "CRASH REPORT " ++ format_crash_report(Self, Neighbours));

+            ?LOGMSG(Sink, error, Pid, "CRASH REPORT " ++ format_crash_report(Self, Neighbours));

         {warning_msg, _GL, {Pid, Fmt, Args}} ->

-            ?LOGMSG(warning, Pid, lager:safe_format(Fmt, Args, ?DEFAULT_TRUNCATION));

+            ?LOGFMT(Sink, warning, Pid, Fmt, Args);

         {warning_report, _GL, {Pid, std_warning, Report}} ->

-            ?LOGMSG(warning, Pid, print_silly_list(Report));

+            ?LOGMSG(Sink, warning, Pid, print_silly_list(Report));

         {info_msg, _GL, {Pid, Fmt, Args}} ->

-            ?LOGMSG(info, Pid, lager:safe_format(Fmt, Args, ?DEFAULT_TRUNCATION));

+            ?LOGFMT(Sink, info, Pid, Fmt, Args);

         {info_report, _GL, {Pid, std_info, D}} when is_list(D) ->

             Details = lists:sort(D),

             case Details of

                 [{application, App}, {exited, Reason}, {type, _Type}] ->

-                    ?LOGFMT(info, Pid, "Application ~w exited with reason: ~s",

-                        [App, format_reason(Reason)]);

+                    case application:get_env(lager, suppress_application_start_stop) of

+                        {ok, true} when Reason == stopped ->

+                            ok;

+                        _ ->

+                            ?LOGFMT(Sink, info, Pid, "Application ~w exited with reason: ~s",

+                                    [App, format_reason(Reason)])

+                    end;

                 _ ->

-                    ?LOGMSG(info, Pid, print_silly_list(D))

+                    ?LOGMSG(Sink, info, Pid, print_silly_list(D))

             end;

         {info_report, _GL, {Pid, std_info, D}} ->

-            ?LOGFMT(info, Pid, "~w", [D]);

+            ?LOGFMT(Sink, info, Pid, "~w", [D]);

         {info_report, _GL, {P, progress, D}} ->

             Details = lists:sort(D),

             case Details of

                 [{application, App}, {started_at, Node}] ->

-                    ?LOGFMT(info, P, "Application ~w started on node ~w",

-                        [App, Node]);

+                    case application:get_env(lager, suppress_application_start_stop) of

+                        {ok, true} ->

+                            ok;

+                        _ ->

+                            ?LOGFMT(Sink, info, P, "Application ~w started on node ~w",

+                                    [App, Node])

+                    end;

                 [{started, Started}, {supervisor, Name}] ->

                     MFA = format_mfa(get_value(mfargs, Started)),

                     Pid = get_value(pid, Started),

-                    ?LOGFMT(debug, P, "Supervisor ~w started ~s at pid ~w",

+                    ?LOGFMT(Sink, debug, P, "Supervisor ~w started ~s at pid ~w",

                         [supervisor_name(Name), MFA, Pid]);

                 _ ->

-                    ?LOGMSG(info, P, "PROGRESS REPORT " ++ print_silly_list(D))

+                    ?LOGMSG(Sink, info, P, "PROGRESS REPORT " ++ print_silly_list(D))

             end;

         _ ->

-            ?LOGFMT(warning, self(), "Unexpected error_logger event ~w", [Event])

+            ?LOGFMT(Sink, warning, self(), "Unexpected error_logger event ~w", [Event])

     end,

     {ok, State}.

@@ -308,7 +326,7 @@

 format_reason({if_clause, [MFA|_]}) ->

     ["no true branch found while evaluating if expression in ", format_mfa(MFA)];

 format_reason({{try_clause, Val}, [MFA|_]}) ->

-    ["no try clause matching ", print_val(Val), " in ", format_mfa(MFA)]; 

+    ["no try clause matching ", print_val(Val), " in ", format_mfa(MFA)];

 format_reason({badarith, [MFA|_]}) ->

     ["bad arithmetic expression in ", format_mfa(MFA)];

 format_reason({{badmatch, Val}, [MFA|_]}) ->

@@ -343,6 +361,8 @@

             %% seems to be generated by a bad call to a BIF

             ["bad argument in ", format_mfa(MFA)]

     end;

+format_reason({{badarg, Stack}, _}) ->

+    format_reason({badarg, Stack});

 format_reason({{badarity, {Fun, Args}}, [MFA|_]}) ->

     {arity, Arity} = lists:keyfind(arity, 1, erlang:fun_info(Fun)),

     [io_lib:format("fun called with wrong arity of ~w instead of ~w in ",

​

@@ -3,7 +3,7 @@

 {application, lager,

  [

   {description, "Erlang logging framework"},

-  {vsn, "2.1.0"},

+  {vsn, "3.1.0"},

   {modules, []},

   {applications, [

                   kernel,

@@ -13,9 +13,9 @@

   {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 

+            %% 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, [

@@ -43,14 +43,18 @@

             %% Number of rotated crash logs to keep, 0 means keep only the

             %% current one - default is 0

             {crash_log_count, 5},

-            %% Whether to redirect error_logger messages into lager - defaults to true

+            %% 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

+            %% 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

+            %% 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}

         ]}

  ]}.

​

@@ -21,17 +21,21 @@

 -include("lager.hrl").

 -define(LAGER_MD_KEY, '__lager_metadata').

+-define(TRACE_SINK, '__trace_sink').

+-define(ROTATE_TIMEOUT, 100000).

 %% API

 -export([start/0,

-        log/3, log/4,

+        log/3, log/4, log/5,

+        log_unsafe/4,

         md/0, md/1,

+        rotate_handler/1, rotate_handler/2, rotate_sink/1, rotate_all/0,

         trace/2, trace/3, trace_file/2, trace_file/3, trace_file/4, trace_console/1, trace_console/2,

-        clear_all_traces/0, stop_trace/1, status/0, 

-        get_loglevel/1, set_loglevel/2, set_loglevel/3, get_loglevels/0,

-        update_loglevel_config/0, posix_error/1,

-        safe_format/3, safe_format_chop/3, dispatch_log/5, dispatch_log/9, 

-        do_log/9, pr/2]).

+        list_all_sinks/0, clear_all_traces/0, stop_trace/1, stop_trace/3, status/0,

+        get_loglevel/1, get_loglevel/2, set_loglevel/2, set_loglevel/3, set_loglevel/4, get_loglevels/1,

+        update_loglevel_config/1, posix_error/1, set_loghwm/2, set_loghwm/3, set_loghwm/4,

+        safe_format/3, safe_format_chop/3, unsafe_format/2, dispatch_log/5, dispatch_log/7, dispatch_log/9,

+        do_log/9, do_log/10, do_log_unsafe/10, pr/2, pr/3, pr_stacktrace/1, pr_stacktrace/2]).

 -type log_level() :: debug | info | notice | warning | error | critical | alert | emergency.

 -type log_level_number() :: 0..7.

@@ -81,51 +85,85 @@

 md(_) ->

     erlang:error(badarg).

--spec dispatch_log(log_level(), list(), string(), list() | none, pos_integer()) ->  ok | {error, lager_not_running}.

+

+-spec dispatch_log(atom(), log_level(), list(), string(), list() | none, pos_integer(), safe | unsafe) ->  ok | {error, lager_not_running} | {error, {sink_not_configured, atom()}}.