Gathering runtime statistics about function calls across entire app

[gmile]

How does one approach gathering runtime statistics about function calls from modules that belong to a specific app?

In my app, using a combination of decorator and telemetry packages, I am able to collect statistics about function calls like this:

defmodule MyApp.FunctionTracing do use Decorator.Define, span: 0 def span(body, context) do quote do metadata = %{ function: "#{unquote(context.module)}.#{unquote(context.name)}/#{unquote(length(context.args))}" } :telemetry.span([:my_app, :function_call], metadata, fn -> {unquote(body), metadata} end) end end end defmodule MyApp.MyModule do use MyApp.FunctionTracing @decorate span() def create_session(args) do # ... end end 

This is then exposed via a family of telemetry packages in a form of GET /metrics endpoint for Prometheus collector to come and pick up.

I can do the above manually for functions that I suspect may not be called. Could someone think of a way to scale this approach? E.g. is there a way I could tell Elixir compiler: please, when compiling ALL modules that belong to my own app, do wrap them in such a way?

The end goal here is to highlight & eliminate dead from from a fairly large codebase. Having all functions instrumented this way, I’d deploy the code in staging or production, collect the statistics for a week or two, then use it to base decisions about code clean up.

Or is this too crazy of a thing to want for such a use case? If it’s too crazy, what would be a good alternative?

I’ve heard one could go a long way with tools already available in Erlang VM / stdlib for tracing and such, - if so, could someone point me in the right direction? At this point all I’m interested in is just counting all function calls coming from modules that belong to my own app.

Ideally, after a week or two of “counting”, I could filter out all function calls with 0 calls, and begin cleaning up the code.

[LostKobrakai]

I’d start with GitHub - hauleth/mix_unused: Find unused functions in your project unless you’re using apply in many places.

[gmile]

Thanks for bringing this one up - we tried it, and eventually were able to removed some code.

Btw, in our case because the main app is an umbrella type app (working on removing the “umbrela” from it atm…) which made the tool somewhat fail to work. So we ended up using a custom compilation tracing script to locate some of the un-used functions.

Next step currently is runtime analysis, and this is where am I looking for new ideas how to approach it.

[al2o3cr]

@gmile

I’ve heard one could go a long way with tools already available in Erlang VM / stdlib for tracing and such, - if so, could someone point me in the right direction?

This article discusses the BEAM’s tracing machinery and some of the Elixir wrappers available.

[LostKobrakai]

And this is a much more practical introduction: Debugging With Tracing in Elixir
For elixir I suggest Extrace to also get elixir syntax for traces.

[gmile]

E.g. is there a way I could tell Elixir compiler: please, when compiling ALL modules that belong to my own app, do wrap them in such a way?

Btw I guess the following can be considered an answer to my question above:

How to change AST before Elixir compilation

Not possible. By design. We want to avoid anything that goes and globally changes code, without a trace. You can hand roll, as in your current solution, but it will have pitfalls such as losing incremental compilation. I would suggest taking a step back and discuss what you want to solve and try to find a way that would be considered idiomatic Elixir. Sorry if this is not the answer you were looking for.

[voltone]

This may be relatively safe in production:

On application startup, call :erlang.trace_pattern({:_, :_, :_}, true, [:call_count]). If code loading is dynamic (i.e. you’re not running as part of a release), also call :erlang.trace_pattern(:on_load, true, [:call_count]).

Then whenever you want to gather call stats for all public functions that have been called at least once:

for {m, _} <- :code.all_loaded(), {f, a} <- m.module_info(:functions), {:call_count, c} = :erlang.trace_info({m, f, a}, :call_count), c > 0, do: {{m, f, a}, c} # or if you prefer: {"#{inspect(m)}.#{f}/#{a}", c} 

If you want to include functions that were never called, just drop the c > 0, line.

Or, for your use-case of finding unused functions in a given application:

app = :my_app for m <- Application.spec(app)[:modules], {f, a} <- m.module_info(:functions), {:call_count, c} = :erlang.trace_info({m, f, a}, :call_count), c == 0, do: {{m, f, a}, c} # or if you prefer: {"#{inspect(m)}.#{f}/#{a}", c} 

In that case you can also selectively enable call count tracing for only the modules of your application, instead of for all modules in the system.

You can reset the counters with :erlang.trace_pattern({:_, :_, :_}, :restart, [:call_count]) or stop tracing with :erlang.trace_pattern({:_, :_, :_}, false, [:call_count]).

[gmile]

This is pure gold. I’m going to try this, thank you so much for taking the time to write examples!