Elixir 堆栈跟踪是否包括每个输入的 function？

Question

I am working on an issue in Postgrex , an Elixir Postgres driver.

However, I am confused by the stacktrace below. (To make it readable I have removed only the lengthy arguments to msg_recv/4 .)

16:52:54.323 [error] GenServer #PID<0.234.0> terminating
** (FunctionClauseError) no function clause matching in Postgrex.Protocol.msg_recv/4
    (postgrex 0.15.5) lib/postgrex/protocol.ex:2837: Postgrex.Protocol.msg_recv(...SNIP)
    (postgrex 0.15.5) lib/postgrex/protocol.ex:816: Postgrex.Protocol.bootstrap_recv/4
    (postgrex 0.15.5) lib/postgrex/protocol.ex:579: Postgrex.Protocol.handshake/2
    (db_connection 2.1.0) lib/db_connection/connection.ex:69: DBConnection.Connection.connect/2
    (connection 1.0.4) lib/connection.ex:622: Connection.enter_connect/5
    (stdlib 3.12.1) proc_lib.erl:249: :proc_lib.init_p_do_apply/3
Last message: nil
State: Postgrex.Protocol

The stacktrace appears to indicate handshake/2 calls bootstrap_recv/4 , but there is no direct call to bootstrap_recv/4 in handshake/2 .

Line 579 is indeed inside handshake/2 , and is a call to do_handshake/2 , of which there are two variants which themselves call ssl/2 or startup/2 .

I cannot find where bootstrap_recv/4 is called in this code path.

Why are do_handshake/2 and one of ssl/2 and startup/2 (and whatever other subsequent calls lead to bootstrap_recv/4 and ultimately msg_recv/4 ) not in the stacktrace?

Presumably, I misunderstand Elixir stacktraces.

Answer 1

EDIT: Such a detailed question for a general issue is a shame, but I'll leave the question in case anyone comes to this situation via debugging.

No, stacktraces in Elixir do not contain every entered function due to the Erlang VM. I found mention of this in a post on the Elixir forum. It is also mentioned in this GitHub issue .

On the erlang-questions mailing list, Joe Armstrong mentions Erlang refers to this as " last call optimization ", and gives an explanation.

The code below with a few trivial lines to prevent tail-calling demonstrates the difference.

defmodule Demo do
  def first() do
    second()

    # Uncomment to prevent tail-call, and `first` appears in the stacktrace.
    # case second() do
    #   _ -> {:ok, 0}
    # end
  end

  # Elixir knows third() is still a tail-call.
  def second() do
    r = third()
    _ = 1 + 1
    # dummy() # Uncomment to prevent tail-call, and `second` appears in the stacktrace.
    r
  end

  def third() do
    IO.inspect(Process.info(self(), :current_stacktrace))
    {:ok, 0}
  end

  defp dummy, do: nil
end

IO.inspect(Demo.first)

Results in stacktrace:

{:current_stacktrace,
 [
   {Process, :info, 2, [file: 'lib/process.ex', line: 765]},
   {Demo, :third, 0, [file: 'demo.exs', line: 21]},
   {:elixir_compiler_0, :__FILE__, 1, [file: 'demo.exs', line: 30]},
   {:elixir_compiler, :dispatch, 4, [file: 'src/elixir_compiler.erl', line: 75]},
   {:elixir_compiler, :compile, 3, [file: 'src/elixir_compiler.erl', line: 60]},
   {:elixir_lexical, :run, 3, [file: 'src/elixir_lexical.erl', line: 15]},
   {:elixir_compiler, :quoted, 3, [file: 'src/elixir_compiler.erl', line: 18]}
 ]}
{:ok, 0}

While adjusting the commented lines (as mentioned) in the same code results in stacktrace:

{:current_stacktrace,
 [
   {Process, :info, 2, [file: 'lib/process.ex', line: 765]},
   {Demo, :third, 0, [file: 'demo.exs', line: 20]},
   {Demo, :second, 0, [file: 'demo.exs', line: 13]},
   {Demo, :first, 0, [file: 'demo.exs', line: 6]},
   {:elixir_compiler_0, :__FILE__, 1, [file: 'demo.exs', line: 29]},
   {:elixir_compiler, :dispatch, 4, [file: 'src/elixir_compiler.erl', line: 75]},
   {:elixir_compiler, :compile, 3, [file: 'src/elixir_compiler.erl', line: 60]}
 ]}
{:ok, 0}