How to keep the Code.eval_string environment on async execution

Questions / Help
1

What is the proper way to evaluate a string and get a stack trace that honors the provided file: script.exs environment across all the code defined in that script regardless of whether it is executed in the current process or deferred to an async task?

The first two samples refer to the provided file: script.exs on the stack trace and the last one loses it.

Sample 1 keeps the reference to script.exs in its stacktrace

iex(1)> Code.eval_string("""
try do
  raise "RAISE"
rescue
  e -> {e, __STACKTRACE__}
end
""", [], file: "script.exs")

{{%RuntimeError{message: "RAISE"},
[
  {:elixir_eval, :__FILE__, 1, [file: ~c"script.exs", line: 2]},
  {:elixir, :eval_external_handler, 3,
   [file: ~c"src/elixir.erl", line: 386, error_info: %{module: Exception}]},
   ...
]}, []}

Sample 2 keeps the reference to script.exs in its stacktrace

iex(2)> Code.eval_string("""
fun = fn -> raise "RAISE" end
try do
  fun.()
rescue
  e -> {e, __STACKTRACE__}
end
""", [], file: "script.exs") 
{{%RuntimeError{message: "RAISE"},
[
  {:elixir_eval, :__FILE__, 1, [file: ~c"script.exs", line: 1]},
  {:elixir, :eval_external_handler, 3,
   [file: ~c"src/elixir.erl", line: 386, error_info: %{module: Exception}]},
  ...
]}, [fun: #Function<43.81571850/0 in :erl_eval.expr/6>]}

Sample 3 loses the reference to script.exs in its stacktrace

iex(3)> Code.eval_string("""
fun = fn -> raise "RAISE" end
Task.async(fn -> 
  try do
    fun.()
  rescue
    e -> {e, __STACKTRACE__}
  end
end) |> Task.await(:infinity)
""", [], file: "script.exs")
{{%RuntimeError{message: "RAISE"},
[
  {:elixir, :eval_external_handler, 3,
   [file: ~c"src/elixir.erl", line: 386, error_info: %{module: Exception}]},
  {:erl_eval, :do_apply, 7, [file: ~c"erl_eval.erl", line: 919]},
  {:erl_eval, :try_clauses, 10, [file: ~c"erl_eval.erl", line: 1233]},
  {Task.Supervised, :invoke_mfa, 2,
   [file: ~c"lib/task/supervised.ex", line: 101]}
]}, [fun: #Function<43.81571850/0 in :erl_eval.expr/6>]}

Need this to implement scripting with accurate tracing of unhandled exceptions in async code.

Things looking into at the moment:

  1. Process.info(self(), :current_stacktrace)
  2. Last call optimisation
2

What happens in the last example if you call List.flatten([]) or any similar example, so the last instruction is not raise, but something else to prevent last call optimization on raise?

3

You mean like sample below? Apparently the reference to script.exs is lost as well.

iex(4)> Code.eval_string(
  """
  fun = fn ->
    raise "RAISE"
    List.flatten([])
  end

  Task.async(fn ->
    try do
      fun.()
    rescue
      e -> {e, __STACKTRACE__}
    end
  end) |> Task.await(:infinity)
  """,
  [],
  file: "script.exs"
)

{{%RuntimeError{message: "RAISE"},
[
  {:elixir, :eval_external_handler, 3,
   [file: ~c"src/elixir.erl", line: 386, error_info: %{module: Exception}]},
  {:erl_eval, :do_apply, 7, [file: ~c"erl_eval.erl", line: 919]},
  {:erl_eval, :exprs, 6, [file: ~c"erl_eval.erl", line: 271]},
  {:erl_eval, :try_clauses, 10, [file: ~c"erl_eval.erl", line: 1233]},
  {Task.Supervised, :invoke_mfa, 2,
   [file: ~c"lib/task/supervised.ex", line: 101]}
]}, [fun: #Function<43.81571850/0 in :erl_eval.expr/6>]}
1 Like
4

Yes, that’s what I meant, but I was able to reproduce the issue in the shell too.

Unfortunately evaluation has less precise stacktraces because it is literally implemented by emulating the runtime in pure Erlang/Elixir and I think splitting the anonymous function is exactly those trade-offs. I will try to see if some aspects can be improved upstream, but it may not be trivial (or it may make things more expensive).

5

Wait, there’s a BEAM emulator in the codebase?! That is not how I expected that to work at all, lol. Out of curiosity, where would I find that code?

6

Oh, it works on Erlang AST rather than BEAM. :smiley: you can find it on erl_eval.

1 Like
7

Found this notice which seems to explain it.

2 Likes