Allow configurable timeout and catch exits on logger

Author: José Valim

lib/logger/lib/logger.ex

@@ -67,6 +67,9 @@ defmodule Logger do
       cause the message to be ignored. Keep in mind that each backend
       may have its specific level, too.
 
+    * `:timeout` - the timeout for sync requests in miliseconds, defaults
+      to 5000 miliseconds.
+
     * `:utc_log` - when `true`, uses UTC in logs. By default it uses
       local time (i.e. it defaults to `false`).
 
@@ -364,19 +367,22 @@ defmodule Logger do
   Use this function only when there is a need to log dynamically
   or you want to explicitly avoid embedding metadata.
   """
-  @spec log(level, IO.chardata | (() -> IO.chardata), Keyword.t) :: :ok | {:error, :not_available}
+  @spec log(level, IO.chardata | (() -> IO.chardata), Keyword.t) ::
+        :ok | {:error, :noproc} | {:error, :timeout} | {:error, term}
   def log(level, chardata, metadata \\ []) when level in @levels and is_list(metadata) do
-    %{mode: mode, truncate: truncate,
+    %{mode: mode, truncate: truncate, timeout: timeout,
       level: min_level, utc_log: utc_log?} = Logger.Config.__data__
 
     if compare_levels(level, min_level) != :lt do
       tuple = {Logger, truncate(chardata, truncate), Logger.Utils.timestamp(utc_log?),
                [pid: self()] ++ metadata() ++ metadata}
       try do
-        notify(mode, {level, Process.group_leader(), tuple})
+        notify(mode, {level, Process.group_leader(), tuple}, timeout)
         :ok
       rescue
-        ArgumentError -> {:error, :not_available}
+        ArgumentError -> {:error, :noproc}
+      catch
+        :exit, {reason, _} -> {:error, reason}
       end
     else
       :ok
@@ -453,6 +459,6 @@ defmodule Logger do
   defp truncate(data, n) when is_list(data) or is_binary(data),
     do: Logger.Utils.truncate(data, n)
 
-  defp notify(:sync, msg),  do: GenEvent.sync_notify(Logger, msg)
-  defp notify(:async, msg), do: GenEvent.notify(Logger, msg)
+  defp notify(:sync, msg, timeout),   do: GenEvent.sync_notify(Logger, msg, timeout)
+  defp notify(:async, msg, _timeout), do: GenEvent.notify(Logger, msg)
 end

lib/logger/lib/logger/config.ex

@@ -134,14 +134,15 @@ defmodule Logger.Config do
 
   defp compute_state(mode) do
     level       = Application.get_env(:logger, :level)
+    timeout     = Application.get_env(:logger, :timeout)
     utc_log     = Application.get_env(:logger, :utc_log)
     truncate    = Application.get_env(:logger, :truncate)
     translators = Application.get_env(:logger, :translators)
 
     sync_threshold  = Application.get_env(:logger, :sync_threshold)
     async_threshold = trunc(sync_threshold * 0.75)
 
-    persist %{level: level, mode: mode, truncate: truncate,
+    persist %{level: level, mode: mode, timeout: timeout, truncate: truncate,
               utc_log: utc_log, sync_threshold: sync_threshold,
               async_threshold: async_threshold, translators: translators}
   end

lib/logger/mix.exs

@@ -11,6 +11,7 @@ defmodule Logger.Mixfile do
     [registered: [Logger, Logger.Supervisor, Logger.Watcher],
      mod: {Logger.App, []},
      env: [level: :debug,
+           timeout: 5000,
            utc_log: false,
            truncate: 8096,
            backends: [:console],

lib/logger/test/logger_test.exs

@@ -161,7 +161,7 @@ defmodule LoggerTest do
     Process.unregister(Logger)
 
     try do
-      assert Logger.log(:debug, "hello") == {:error, :not_available}
+      assert Logger.log(:debug, "hello") == {:error, :noproc}
     after
       Process.register(logger, Logger)
     end