Warn on errors from orphan compiler modules

Author: josevalim

lib/elixir/lib/task/supervised.ex

@@ -123,7 +123,8 @@ defmodule Task.Supervised do
               args: args,
               reason: {log_value(kind, value), __STACKTRACE__},
               # using :proc_lib over Process because we want the :undefined default, not nil
-              process_label: :proc_lib.get_label(self())
+              process_label: :proc_lib.get_label(self()),
+              orphan_compiler_module?: orphan_compiler_module?(kind, value)
             }
           },
           %{
@@ -138,6 +139,23 @@ defmodule Task.Supervised do
     end
   end
 
+  defp orphan_compiler_module?(kind, reason) do
+    with :error <- kind,
+         :undef <- reason,
+         {:error_handler, :error_handler} <- :erlang.process_info(self(), :error_handler),
+         {:parent, parent} <- :erlang.process_info(self(), :parent),
+         {:error_handler, Kernel.ErrorHandler} <-
+           (try do
+              :erlang.process_info(parent, :error_handler)
+            rescue
+              _ -> nil
+            end) do
+      true
+    else
+      _ -> false
+    end
+  end
+
   defp exit_reason(:error, reason, stacktrace), do: {reason, stacktrace}
   defp exit_reason(:exit, reason, _stacktrace), do: reason
   defp exit_reason(:throw, reason, stacktrace), do: {{:nocatch, reason}, stacktrace}

lib/logger/lib/logger/translator.ex

@@ -106,18 +106,30 @@ defmodule Logger.Translator do
            starter: starter,
            function: function,
            args: args,
-           reason: reason,
+           reason: report_reason,
            process_label: process_label
-         }}
+         } = report}
       ) do
     opts = Application.get_env(:logger, :translator_inspect_opts)
 
-    {formatted, reason} = format_reason(reason)
+    {formatted, reason} = format_reason(report_reason)
     metadata = [crash_reason: reason] ++ registered_name(name)
 
     msg =
-      ["\nFunction: #{inspect(function, opts)}"] ++
-        ["\n    Args: #{inspect(args, opts)}"]
+      case report do
+        %{orphan_compiler_module?: true} when elem(report_reason, 0) == :undef ->
+          [
+            "\n    Hint: if this module is defined somewhere, this error may have happened because processes " <>
+              "were spawned during Elixir's compilation and these processes are unable to load modules defined " <>
+              "by the compiler. In such cases, consider using Kernel.ParallelCompiler.pmap/2 instead"
+          ]
+
+        _ ->
+          []
+      end
+
+    msg =
+      ["\nFunction: #{inspect(function, opts)}\n    Args: #{inspect(args, opts)}"] ++ msg
 
     msg =
       case process_label do

lib/logger/test/logger/translator_test.exs

@@ -665,6 +665,30 @@ defmodule Logger.TranslatorTest do
     assert {%UndefinedFunctionError{function: :undef}, [_ | _]} = task_metadata[:crash_reason]
   end
 
+  test "translates Task undef function crash with orphan compiler module" do
+    # Start once so all modules are loaded
+    Task.start(__MODULE__, :undef, [])
+
+    assert capture_log(fn ->
+             try do
+               :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
+               {:ok, pid} = Task.start(__MODULE__, :undef, [])
+               ref = Process.monitor(pid)
+               receive do: ({:DOWN, ^ref, _, _, _} -> :ok)
+             after
+               :erlang.process_flag(:error_handler, :error_handler)
+             end
+           end) =~
+             "Hint: if this module is defined somewhere, this error may have happened because processes were spawned during Elixir's compilation"
+
+    assert_receive {:event,
+                    {:report,
+                     %{
+                       label: {Task.Supervisor, :terminating},
+                       report: %{orphan_compiler_module?: true}
+                     }}, _task_metadata}
+  end
+
   test "translates Task raising ErlangError" do
     parent = self()