Missing traces on attribute calls

[lukaszsamson]

Elixir and Erlang/OTP versions

Erlang/OTP 27 [erts-15.2.5] [source] [64-bit] [smp:12:12] [ds:12:12:10] [async-threads:1] [jit]

Elixir 1.18.3 (compiled with Erlang/OTP 27)

Operating system

any

Current behavior

The following code example when a call on attribute happens inside module body do not emit remote_function tracer events

defmodule Foo do
  @x Enum

  @x.count([])
end

Only alias_reference is emitted here.

Compare that with the call in function body which emits the event

defmodule Foo do
  @x Enum

  def go do
    @x.count([])
  end
end

Or indirect call

defmodule Foo do
  Enum.count([])
end

Similarly, a capture call will not emit the event in module body

defmodule Foo do
  @x (&Enum.count/1)

  @x.([])
end

defmodule Foo do
  import Enum

  @x (&count/1)

  @x.([])
end

But will emit in function body

defmodule Foo do
  @x (&Enum.count/1)

  def go do
    @x.([])
  end
end

Additionally, if a module variable is used instead of an attribute the same bahaviour can be observed - no trace events emitted

defmodule Foo do
  x = Enum

  x.count([])
end

defmodule Foo do
  x = (&Enum.count/1)

  x.([])
end

As far as I can tell, the compile time dependencies are correctly set

Expected behavior

The calls in the examples with attributes should emit tracer events. I'm not sure about the calls on module variable.

[lukaszsamson]

I've found a case where compile dependency is not set:

{{compile, _, _, _}, _binding} =
        Code.eval_string("""
        defmodule Kernel.LexicalTrackerTest.Attribute1 do
          @x :"Elixir.Enum"
          @x.count([])
          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
        end |> elem(3)
        """)

returns:

[Module, Kernel.LexicalTracker, :elixir_utils, Kernel]

expected:

[Module, Kernel.LexicalTracker, :elixir_utils, Kernel, Enum]

[josevalim]

I've found a case where compile dependency is not set:

Correct, when you use the atom directly instead of the alias, you bypass the ability to see all compile-time calls.

The following code example when a call on attribute happens inside module body do not emit remote_function tracer events

I will investigate if we can improve it but the reason this happens is because a module attribute is dynamic outside of a function but static inside a function. The best way to understand it is to see that:

defmodule Foo do
  @x Enum
  @x.count([])

  def go do
    @x.count([])
  end
end

translates to this:

defmodule Foo do
  @x Enum
  Module.get_attribute(__MODULE__, :x).count([])

  def go do
    unquote(Module.get_attribute(__MODULE__, :x)).count([])
  end
end

And the latter becomes Enum.count([]).

However, I want to investigate the function capture case. It seems that one should emit an event because we can see the whole call.

[lukaszsamson]

Correct, when you use the atom directly instead of the alias, you bypass the ability to see all compile-time calls.

OK, but using an atom is not the reason. The same code without going through an attribute works

:"Elixir.Enum".count([])

[josevalim]

Yes, because we can see it is a call at compile time, we can’t say otherwise. The same if you do: function_that_calls_count(Enum), it won’t see the call count, nor if Enum is a variable. For those cases, it only sees the alias. And if you use an atom, then it does not see the alias nor the call.