include callers in translated Logger metadata for Task (#10111)

Author: mitchellhenke

lib/elixir/lib/task/supervised.ex

@@ -112,7 +112,8 @@ defmodule Task.Supervised do
           %{
             domain: [:otp, :elixir],
             error_logger: %{tag: :error_msg},
-            report_cb: &__MODULE__.format_report/1
+            report_cb: &__MODULE__.format_report/1,
+            callers: Process.get(:"$callers")
           }
         )
 

lib/logger/test/logger/translator_test.exs

@@ -306,6 +306,7 @@ defmodule Logger.TranslatorTest do
 
   test "translates Task crashes" do
     {:ok, pid} = Task.start_link(__MODULE__, :task, [self()])
+    parent = self()
 
     assert capture_log(fn ->
              ref = Process.monitor(pid)
@@ -324,6 +325,7 @@ defmodule Logger.TranslatorTest do
 
     assert {%RuntimeError{message: "oops"}, [_ | _]} = task_metadata[:crash_reason]
     assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
+    assert [parent] == task_metadata[:callers]
 
     refute Keyword.has_key?(task_metadata, :initial_call)
     assert process_metadata[:initial_call] == {Logger.TranslatorTest, :task, 1}
@@ -332,6 +334,7 @@ defmodule Logger.TranslatorTest do
   test "translates Task async_stream crashes with neighbour" do
     fun = fn -> Task.async_stream([:oops], :erlang, :error, []) |> Enum.to_list() end
     {:ok, pid} = Task.start(__MODULE__, :task, [self(), fun])
+    parent = self()
 
     assert capture_log(:debug, fn ->
              ref = Process.monitor(pid)
@@ -345,12 +348,15 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [pid, parent] == task_metadata[:callers]
 
     assert {:oops, [_ | _]} = task_metadata[:crash_reason]
     assert {%ErlangError{original: :oops}, [_ | _]} = process_metadata[:crash_reason]
   end
 
   test "translates Task undef module crash" do
+    parent = self()
+
     assert capture_log(fn ->
              {:ok, pid} = Task.start(:module_does_not_exist, :undef, [])
              ref = Process.monitor(pid)
@@ -365,12 +371,15 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [parent] == task_metadata[:callers]
 
     assert {%UndefinedFunctionError{function: :undef}, [_ | _]} = task_metadata[:crash_reason]
     assert {%UndefinedFunctionError{function: :undef}, [_ | _]} = process_metadata[:crash_reason]
   end
 
   test "translates Task undef function crash" do
+    parent = self()
+
     assert capture_log(fn ->
              {:ok, pid} = Task.start(__MODULE__, :undef, [])
              ref = Process.monitor(pid)
@@ -385,12 +394,15 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [parent] == task_metadata[:callers]
 
     assert {%UndefinedFunctionError{function: :undef}, [_ | _]} = task_metadata[:crash_reason]
     assert {%UndefinedFunctionError{function: :undef}, [_ | _]} = process_metadata[:crash_reason]
   end
 
   test "translates Task raising ErlangError" do
+    parent = self()
+
     assert capture_log(fn ->
              exception =
                try do
@@ -413,12 +425,15 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [parent] == task_metadata[:callers]
 
     assert {%ErlangError{original: :foo}, [_ | _]} = task_metadata[:crash_reason]
     assert {%ErlangError{original: :foo}, [_ | _]} = process_metadata[:crash_reason]
   end
 
   test "translates Task raising Erlang badarg error" do
+    parent = self()
+
     assert capture_log(fn ->
              {:ok, pid} = Task.start(:erlang, :error, [:badarg])
              ref = Process.monitor(pid)
@@ -433,12 +448,15 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [parent] == task_metadata[:callers]
 
     assert {%ArgumentError{message: "argument error"}, [_ | _]} = task_metadata[:crash_reason]
     assert {%ArgumentError{message: "argument error"}, [_ | _]} = process_metadata[:crash_reason]
   end
 
   test "translates Task exiting abnormally" do
+    parent = self()
+
     assert capture_log(fn ->
              {:ok, pid} = Task.start(:erlang, :exit, [:abnormal])
              ref = Process.monitor(pid)
@@ -453,6 +471,7 @@ defmodule Logger.TranslatorTest do
 
     assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
     assert_receive {:error, _pid, {Logger, ["Process " | _], _ts, process_metadata}}
+    assert [parent] == task_metadata[:callers]
 
     assert {:abnormal, [_ | _]} = task_metadata[:crash_reason]
     assert {:abnormal, [_ | _]} = process_metadata[:crash_reason]
@@ -625,8 +644,9 @@ defmodule Logger.TranslatorTest do
            """
   end
 
-  test "translates :proc_lib crashes on debug" do
+  test "translates :proc_lib+Task crashes on debug" do
     {:ok, pid} = Task.start_link(__MODULE__, :task, [self()])
+    parent = self()
 
     assert capture_log(:debug, fn ->
              ref = Process.monitor(pid)
@@ -652,13 +672,15 @@ defmodule Logger.TranslatorTest do
     assert process_metadata[:pid] == task_metadata[:pid]
     assert is_list(process_metadata[:callers])
     assert is_list(process_metadata[:ancestors])
+    assert [parent] == task_metadata[:callers]
 
     assert {%RuntimeError{message: "oops"}, [_ | _]} = task_metadata[:crash_reason]
     assert {%RuntimeError{message: "oops"}, [_ | _]} = process_metadata[:crash_reason]
   end
 
-  test "translates :proc_lib crashes with neighbour on debug" do
+  test "translates :proc_lib+Task crashes with neighbour on debug" do
     {:ok, pid} = Task.start_link(__MODULE__, :sub_task, [self()])
+    parent = self()
 
     assert capture_log(:debug, fn ->
              ref = Process.monitor(pid)
@@ -677,6 +699,9 @@ defmodule Logger.TranslatorTest do
                    Current Stacktrace:
                        (lib/logger/)?test/logger/translator_test.exs:\d+: Logger.TranslatorTest.sleep/1
            """
+
+    assert_receive {:error, _pid, {Logger, ["Task " <> _ | _], _ts, task_metadata}}
+    assert [parent] == task_metadata[:callers]
   end
 
   test "translates Supervisor progress" do