defmodule Rexbug.Printing do
@moduledoc """
Provides the print handler and helper functions for writing custom
print handlers for `Rexbug`. You shouldn't need to use it directly
unless you want to implement a print handler yourself.
See `Rexbug.start/2` `print_fun` option for details.
"""
alias Rexbug.Printing
import Rexbug.Printing.Utils
# ===========================================================================
# Helper Structs
# ===========================================================================
defmodule MFA do
@type t :: %__MODULE__{}
defstruct [
:m,
:f,
# either args or arity
:a
]
def from_erl({m, f, a}) do
%__MODULE__{m: m, f: f, a: a}
end
def from_erl(a) when is_atom(a) or is_list(a) do
a
end
def represent(a, _opts) when is_atom(a) or is_list(a) do
"(#{inspect(a)})"
end
def represent(%__MODULE__{m: m, f: f, a: a}, _opts) do
mrep =
case Atom.to_string(m) do
"Elixir." <> rest -> rest
erlang_module -> ":#{erlang_module}"
end
arep =
if is_list(a) do
middle =
a
|> Enum.map(&printing_inspect/1)
|> Enum.join(", ")
"(#{middle})"
else
"/#{a}"
end
"#{mrep}.#{f}#{arep}"
end
end
defmodule Timestamp do
@type t :: %__MODULE__{}
defstruct ~w(hours minutes seconds us)a
def from_erl({h, m, s, us}) do
%__MODULE__{hours: h, minutes: m, seconds: s, us: us}
end
def represent(%__MODULE__{hours: h, minutes: m, seconds: s, us: us}, opts) do
if Keyword.get(opts, :print_msec, false) do
"#{format_int(h)}:#{format_int(m)}:#{format_int(s)}.#{format_int(div(us, 1000), 3)}"
else
"#{format_int(h)}:#{format_int(m)}:#{format_int(s)}"
end
end
defp format_int(i, length \\ 2) do
i
|> Integer.to_string()
|> String.pad_leading(length, "0")
end
end
# ---------------------------------------------------------------------------
# Received message types
# ---------------------------------------------------------------------------
defmodule Call do
@type t :: %__MODULE__{}
defstruct ~w(mfa dump from_pid from_mfa time)a
def represent(%__MODULE__{} = struct, opts) do
ts = Timestamp.represent(struct.time, opts)
pid = printing_inspect(struct.from_pid)
from_mfa = MFA.represent(struct.from_mfa, opts)
mfa = MFA.represent(struct.mfa, opts)
maybe_stack = represent_stack(struct.dump, opts)
"# #{ts} #{pid} #{from_mfa}\n# #{mfa}#{maybe_stack}"
end
defp represent_stack(nil, _opts), do: ""
defp represent_stack("", _opts), do: ""
defp represent_stack(dump, _opts) do
dump
|> Printing.extract_stack()
|> Enum.map(fn fun_rep -> "\n# #{fun_rep}" end)
|> Enum.join("")
end
end
defmodule Return do
@type t :: %__MODULE__{}
defstruct ~w(mfa return_value from_pid from_mfa time)a
def represent(%__MODULE__{} = struct, opts) do
ts = Timestamp.represent(struct.time, opts)
pid = printing_inspect(struct.from_pid)
from_mfa = MFA.represent(struct.from_mfa, opts)
mfa = MFA.represent(struct.mfa, opts)
retn = printing_inspect(struct.return_value)
"# #{ts} #{pid} #{from_mfa}\n# #{mfa} -> #{retn}"
end
end
defmodule Send do
@type t :: %__MODULE__{}
defstruct ~w(msg to_pid to_mfa from_pid from_mfa time)a
def represent(%__MODULE__{} = struct, opts) do
ts = Timestamp.represent(struct.time, opts)
to_pid = printing_inspect(struct.to_pid)
to_mfa = MFA.represent(struct.to_mfa, opts)
from_pid = printing_inspect(struct.from_pid)
from_mfa = MFA.represent(struct.from_mfa, opts)
msg = printing_inspect(struct.msg)
"# #{ts} #{from_pid} #{from_mfa}\n# #{to_pid} #{to_mfa} <<< #{msg}"
end
end
defmodule Receive do
@type t :: %__MODULE__{}
defstruct ~w(msg to_pid to_mfa time)a
def represent(%__MODULE__{} = struct, opts) do
ts = Timestamp.represent(struct.time, opts)
to_pid = printing_inspect(struct.to_pid)
to_mfa = MFA.represent(struct.to_mfa, opts)
msg = printing_inspect(struct.msg)
"# #{ts} #{to_pid} #{to_mfa}\n# <<< #{msg}"
end
end
# ===========================================================================
# Public Functions
# ===========================================================================
@doc """
The default value for the `Rexbug.start/2` `print_fun` option. Prints out
the tracing messages generated by `:redbug` in a nice Elixir format.
"""
@spec print(tuple()) :: :ok
def print(message) do
# this is not a 2 arg function just so that no-one passes it as the
# print_fun to :redbug, the second argument is not an accumulator
print_with_opts(message, [])
end
@doc false
@spec print_with_opts(tuple(), Keyword.t()) :: :ok
def print_with_opts(message, opts) do
IO.puts("\n" <> format(message, opts))
end
@doc false
def format(message, opts \\ []) do
message
|> from_erl()
|> represent(opts)
end
@doc """
Translates the `:redbug` tuples representing the tracing messages to
Elixir structs.
You can use it to implement your own custom `print_fun`.
"""
@spec from_erl(tuple()) ::
Printing.Call.t()
| Printing.Return.t()
| Printing.Send.t()
| Printing.Receive.t()
| term()
def from_erl({:call, {mfa, dump}, from_pid_mfa, time}) do
{from_pid, from_mfa} = get_pid_mfa(from_pid_mfa)
%Call{
mfa: MFA.from_erl(mfa),
dump: dump,
from_pid: from_pid,
from_mfa: MFA.from_erl(from_mfa),
time: Timestamp.from_erl(time)
}
end
def from_erl({:retn, {mfa, retn}, from_pid_mfa, time}) do
{from_pid, from_mfa} = get_pid_mfa(from_pid_mfa)
%Return{
mfa: MFA.from_erl(mfa),
return_value: retn,
from_pid: from_pid,
from_mfa: MFA.from_erl(from_mfa),
time: Timestamp.from_erl(time)
}
end
def from_erl({:send, {msg, to_pid_mfa}, from_pid_mfa, time}) do
{to_pid, to_mfa} = get_pid_mfa(to_pid_mfa)
{from_pid, from_mfa} = get_pid_mfa(from_pid_mfa)
%Send{
msg: msg,
to_pid: to_pid,
to_mfa: MFA.from_erl(to_mfa),
from_pid: from_pid,
from_mfa: MFA.from_erl(from_mfa),
time: Timestamp.from_erl(time)
}
end
def from_erl({:recv, msg, to_pid_mfa, time}) do
{to_pid, to_mfa} = get_pid_mfa(to_pid_mfa)
%Receive{
msg: msg,
to_pid: to_pid,
to_mfa: MFA.from_erl(to_mfa),
time: Timestamp.from_erl(time)
}
end
# fallthrough so that you can use it indiscriminately
def from_erl(message) do
message
end
defp get_pid_mfa({pid, mfa}) do
{pid, mfa}
end
defp get_pid_mfa(other) when is_atom(other) or is_list(other) do
{nil, other}
end
@doc false
def represent(%mod{} = struct, opts) when mod in [Call, Return, Send, Receive] do
mod.represent(struct, opts)
end
@doc """
Extracts the call stack from `t:Rexbug.Printing.Call.t/0` `dump` field.
**NOTE**: The `dump` field will contain call stack information only
if you specify `" :: stack"` in `Rexbug.start/2`'s trace pattern,
it will be nil or empty otherwise.
"""
@spec extract_stack(String.t()) :: [String.t()]
def extract_stack(dump) do
String.split(dump, "\n")
|> Enum.filter(&Regex.match?(~r/Return addr 0x|CP: 0x/, &1))
|> Enum.flat_map(&extract_function/1)
end
# ===========================================================================
# Internal Functions
# ===========================================================================
defp extract_function(line) do
case Regex.run(~r"^.+\((.+):(.+)/(\d+).+\)$", line, capture: :all_but_first) do
[m, f, arity] ->
m = translate_module_from_dump(m)
f = strip_single_quotes(f)
["#{m}.#{f}/#{arity}"]
nil ->
[]
end
end
defp strip_single_quotes(str) do
String.trim(str, "'")
end
defp translate_module_from_dump(module) do
case strip_single_quotes(module) do
"Elixir." <> rest ->
rest
erlang_module ->
":#{erlang_module}"
end
end
end
