Log when tasks go down

Author: José Valim

lib/elixir/lib/agent/server.ex

@@ -44,7 +44,7 @@ defmodule Agent.Server do
     # There is a race condition if the agent is
     # restarted too fast and it is registered.
     try do
-      self |> Process.info(:registered_name) |> elem(1) |> Process.unregister
+      self |> :erlang.process_info(:registered_name) |> elem(1) |> Process.unregister
     rescue
       _ -> :ok
     end

lib/elixir/lib/process.ex

@@ -368,8 +368,18 @@ defmodule Process do
 
   See http://www.erlang.org/doc/man/erlang.html#process_info-2 for more info.
   """
-  @spec info(pid, atom) :: {atom, term}
-  def info(pid, spec) do
+  @spec info(pid, atom) :: {atom, term} | nil
+  def info(pid, spec)
+
+  def info(pid, :registered_name) do
+    case :erlang.process_info(pid, :registered_name) do
+      :undefined -> nil
+      [] -> {:registered_name, nil}
+      other -> other
+    end
+  end
+
+  def info(pid, spec) when is_atom(spec) do
     nillify :erlang.process_info(pid, spec)
   end
 

lib/elixir/lib/task.ex

@@ -106,7 +106,7 @@ defmodule Task do
   """
   @spec start_link(module, atom, [term]) :: {:ok, pid}
   def start_link(mod, fun, args) do
-    Task.Supervised.start_link({mod, fun, args})
+    Task.Supervised.start_link(get_info(self), {mod, fun, args})
   end
 
   @doc """
@@ -135,12 +135,17 @@ defmodule Task do
   @spec async(module, atom, [term]) :: t
   def async(mod, fun, args) do
     mfa = {mod, fun, args}
-    pid = :proc_lib.spawn_link(Task.Supervised, :async, [self(), mfa])
+    pid = :proc_lib.spawn_link(Task.Supervised, :async, [self, get_info(self), mfa])
     ref = Process.monitor(pid)
     send(pid, {self(), ref})
     %Task{pid: pid, ref: ref}
   end
 
+  defp get_info(self) do
+    {node(),
+     self |> Process.info(:registered_name) |> elem(1) |> Kernel.||(self)}
+  end
+
   @doc """
   Awaits for a task reply.
 

lib/elixir/lib/task/supervised.ex

@@ -1,20 +1,20 @@
 defmodule Task.Supervised do
   @moduledoc false
 
-  def start_link(fun) do
-    {:ok, :proc_lib.spawn_link(__MODULE__, :noreply, [fun])}
+  def start_link(info, fun) do
+    {:ok, :proc_lib.spawn_link(__MODULE__, :noreply, [info, fun])}
   end
 
-  def start_link(caller, fun) do
-    :proc_lib.start_link(__MODULE__, :reply, [caller, fun])
+  def start_link(caller, info, fun) do
+    :proc_lib.start_link(__MODULE__, :reply, [caller, info, fun])
   end
 
-  def async(caller, mfa) do
+  def async(caller, info, mfa) do
     ref = receive do: ({^caller, ref} -> ref)
-    send caller, {ref, apply(mfa)}
+    send caller, {ref, do_apply(info, mfa)}
   end
 
-  def reply(caller, mfa) do
+  def reply(caller, info, mfa) do
     :erlang.link(caller)
     :proc_lib.init_ack({:ok, self()})
 
@@ -41,21 +41,47 @@ defmodule Task.Supervised do
         5000 -> exit(:timeout)
       end
 
-    send caller, {ref, apply(mfa)}
+    send caller, {ref, do_apply(info, mfa)}
   end
 
-  def noreply(mfa) do
-    apply(mfa)
+  def noreply(info, mfa) do
+    do_apply(info, mfa)
   end
 
-  def apply({module, fun, args}) do
+  defp do_apply(info, {module, fun, args} = mfa) do
     try do
       apply(module, fun, args)
     catch
-      :error, reason ->
-        exit({reason, System.stacktrace()})
+      :error, value ->
+        exit(info, mfa, {value, System.stacktrace()})
       :throw, value ->
-        exit({{:nocatch, value}, System.stacktrace()})
+        exit(info, mfa, {{:nocatch, value}, System.stacktrace()})
+      :exit, value ->
+        exit(info, mfa, value)
     end
   end
+
+  defp exit(_info, _mfa, reason)
+      when reason == :normal
+      when reason == :shutdown
+      when tuple_size(reason) == 2 and elem(reason, 0) == :shutdown do
+    exit(reason)
+  end
+
+  defp exit(info, mfa, reason) do
+    :error_logger.format(
+      "** Task ~p terminating~n" <>
+      "** Started from ~p~n" <>
+      "** Running ~p~n" <>
+      "** Reason for termination == ~n" <>
+      "** ~p~n", [self, get_from(info), get_running(mfa), reason])
+
+    exit(reason)
+  end
+
+  defp get_from({node, pid_or_name}) when node == node(), do: pid_or_name
+  defp get_from(other), do: other
+
+  defp get_running({:erlang, :apply, [fun, []]}), do: fun
+  defp get_running(other), do: other
 end

lib/elixir/lib/task/supervisor.ex

@@ -55,7 +55,8 @@ defmodule Task.Supervisor do
   """
   @spec async(Supervisor.supervisor, module, atom, [term]) :: Task.t
   def async(supervisor, module, fun, args) do
-    {:ok, pid} = Supervisor.start_child(supervisor, [self(), {module, fun, args}])
+    args = [self, get_info(self), {module, fun, args}]
+    {:ok, pid} = Supervisor.start_child(supervisor, args)
     ref = Process.monitor(pid)
     send pid, {self(), ref}
     %Task{pid: pid, ref: ref}
@@ -98,6 +99,11 @@ defmodule Task.Supervisor do
   """
   @spec start_child(Supervisor.supervisor, module, atom, [term]) :: {:ok, pid}
   def start_child(supervisor, module, fun, args) do
-    Supervisor.start_child(supervisor, [{module, fun, args}])
+    Supervisor.start_child(supervisor, [get_info(self), {module, fun, args}])
+  end
+
+  defp get_info(self) do
+    {node(),
+     self |> Process.info(:registered_name) |> elem(1) |> Kernel.||(self)}
   end
 end

lib/elixir/test/elixir/process_test.exs

@@ -14,6 +14,26 @@ defmodule ProcessTest do
            quote(do: :erlang.monitor(:process, pid()))
   end
 
+  test "info/2" do
+    pid = spawn fn -> end
+    Process.exit(pid, :kill)
+    assert Process.info(pid, :backtrace) == nil
+  end
+
+  test "info/2 with registered name" do
+    pid = spawn fn -> end
+    Process.exit(pid, :kill)
+    assert Process.info(pid, :registered_name) ==
+           nil
+
+    assert Process.info(self, :registered_name) ==
+           {:registered_name, nil}
+
+    Process.register(self, __MODULE__)
+    assert Process.info(self, :registered_name) ==
+           {:registered_name, __MODULE__}
+  end
+
   defp expand(expr, env) do
     {expr, _env} = :elixir_exp.expand(expr, env)
     expr

lib/elixir/test/elixir/task/supervisor_test.exs

@@ -8,8 +8,9 @@ defmodule Task.SupervisorTest do
     {:ok, supervisor: pid}
   end
 
-  teardown config do
-    Process.exit(config[:supervisor], :shutdown)
+  setup do
+    :error_logger.tty(false)
+    on_exit fn -> :error_logger.tty(true) end
     :ok
   end
 

lib/elixir/test/elixir/task_test.exs

@@ -3,6 +3,12 @@ Code.require_file "test_helper.exs", __DIR__
 defmodule TaskTest do
   use ExUnit.Case, async: true
 
+  setup do
+    :error_logger.tty(false)
+    on_exit fn -> :error_logger.tty(true) end
+    :ok
+  end
+
   def wait_and_send(caller, atom) do
     receive do: (true -> true)
     send caller, atom