defmodule Ecto.DevLogger do
@moduledoc """
An alternative logger for Ecto queries.
It inlines bindings into the query, so it is easy to copy-paste logged SQL and run it in any IDE for debugging without
manual transformation of common elixir terms to string representation (binary UUID, DateTime, Decimal, json, etc).
Also, it highlights db time to make slow queries noticeable. Source table and inlined bindings are highlighted as well.
"""
require Logger
@type option :: {:log_repo_name, boolean()} | {:ignore_event, (metadata :: map() -> boolean())}
@doc """
Attaches `telemetry_handler/4` to application.
Returns the result from the call to `:telemetry.attach/4` or `:ok` if the repo has default logging enabled.
## Options
* `:log_repo_name` - when truthy will add the repo name into the log.
* `:ignore_event` - a callback which allows to skip some telemetry events thus skip printing logs.
By default, the library ignores events from `Oban` and events related to migration queries.
These checks are not overridable by `:ignore_event` callback and have priority over it.
"""
@spec install(repo_module :: module(), opts :: [option()]) :: :ok | {:error, :already_exists}
def install(repo_module, opts \\ []) when is_atom(repo_module) do
config = repo_module.config()
if config[:log] == false do
:telemetry.attach(
handler_id(repo_module),
config[:telemetry_prefix] ++ [:query],
&__MODULE__.telemetry_handler/4,
opts
)
else
:ok
end
end
@doc """
Detaches a previously attached handler for a given Repo.
Returns the result from the call to `:telemetry.detach/1`
"""
@spec uninstall(repo_module :: module()) :: :ok | {:error, :not_found}
def uninstall(repo_module) when is_atom(repo_module) do
:telemetry.detach(handler_id(repo_module))
end
@doc """
Gets the handler_id for a given Repo.
"""
@spec handler_id(repo_module :: module()) :: list()
def handler_id(repo_module) do
config = repo_module.config()
[:ecto_dev_logger] ++ config[:telemetry_prefix]
end
defp oban_query?(metadata) do
not is_nil(metadata[:options][:oban_conf])
end
defp schema_migration?(metadata) do
metadata[:options][:schema_migration] == true
end
defp ignore_event?(config, metadata) do
oban_query?(metadata) or schema_migration?(metadata) or
(config[:ignore_event] || (&always_false/1)).(metadata)
end
defp always_false(_), do: false
@doc "Telemetry handler which logs queries."
@spec telemetry_handler(
:telemetry.event_name(),
:telemetry.event_measurements(),
:telemetry.event_metadata(),
[option()]
) :: :ok
def telemetry_handler(_event_name, measurements, metadata, config) do
if ignore_event?(config, metadata) do
:ok
else
query = String.Chars.to_string(metadata.query)
color = sql_color(query)
repo_adapter = metadata[:repo].__adapter__()
Logger.debug(
fn ->
query
|> inline_params(metadata.params, color, repo_adapter)
|> log_sql_iodata(measurements, metadata, color, config)
end,
ansi_color: color
)
end
end
@doc false
def inline_params(query, params, _return_to_color, _repo_adapter) when map_size(params) == 0 do
query
end
def inline_params(query, params, return_to_color, repo_adapter)
when repo_adapter in [Ecto.Adapters.Postgres, Ecto.Adapters.Tds] do
params_by_index =
params
|> Enum.with_index(1)
|> Map.new(fn {value, index} -> {index, value} end)
placeholder_with_number_regex = placeholder_with_number_regex(repo_adapter)
String.replace(query, placeholder_with_number_regex, fn
<<_prefix::utf8, index::binary>> = replacement ->
case Map.fetch(params_by_index, String.to_integer(index)) do
{:ok, value} ->
try do
value
|> Ecto.DevLogger.PrintableParameter.to_expression()
|> colorize(IO.ANSI.color(0, 2, 3), apply(IO.ANSI, return_to_color, []))
rescue
Protocol.UndefinedError ->
value
|> inspect()
|> colorize(IO.ANSI.color(5, 0, 0), apply(IO.ANSI, return_to_color, []))
end
:error ->
replacement
end
end)
end
def inline_params(query, params, return_to_color, Ecto.Adapters.MyXQL) do
params_by_index =
params
|> Enum.with_index()
|> Map.new(fn {value, index} -> {index, value} end)
query
|> String.split("?")
|> Enum.map_reduce(0, fn elem, index ->
formatted_value =
case Map.fetch(params_by_index, index) do
{:ok, value} ->
value
|> Ecto.DevLogger.PrintableParameter.to_expression()
|> colorize(IO.ANSI.color(0, 2, 3), apply(IO.ANSI, return_to_color, []))
:error ->
[]
end
{[elem, formatted_value], index + 1}
end)
|> elem(0)
end
defp placeholder_with_number_regex(Ecto.Adapters.Postgres), do: ~r/\$\d+/
defp placeholder_with_number_regex(Ecto.Adapters.Tds), do: ~r/@\d+/
defp log_sql_iodata(query, measurements, metadata, color, config) do
[
"QUERY",
?\s,
log_ok_error(metadata.result),
log_ok_source(metadata.source, color),
log_repo(metadata.repo, color, config),
log_time("db", measurements, :query_time, true, color),
log_time("decode", measurements, :decode_time, false, color),
?\n,
query,
log_stacktrace(metadata[:stacktrace], metadata.repo)
]
end
defp log_ok_error({:ok, _res}), do: "OK"
defp log_ok_error({:error, _err}), do: "ERROR"
defp log_repo(nil, _color, _config), do: ""
defp log_repo(repo, color, config) do
Keyword.get(config, :log_repo_name, false)
|> case do
true -> [" repo=", colorize(inspect(repo), IO.ANSI.blue(), apply(IO.ANSI, color, []))]
_ -> ""
end
end
defp log_ok_source(nil, _color), do: ""
defp log_ok_source(source, color),
do: [" source=", colorize(inspect(source), IO.ANSI.blue(), apply(IO.ANSI, color, []))]
defp log_time(label, measurements, key, force, color) do
case measurements do
%{^key => time} ->
us = System.convert_time_unit(time, :native, :microsecond)
ms = div(us, 100) / 10
if force or ms > 0 do
line = [?\s, label, ?=, :io_lib_format.fwrite_g(ms), ?m, ?s]
case duration_color(ms) do
nil -> line
duration_color -> colorize(line, duration_color, apply(IO.ANSI, color, []))
end
else
[]
end
%{} ->
[]
end
end
@colorize_step 25
defp duration_color(duration) do
if IO.ANSI.enabled?() do
# don't colorize if duration < @colorize_step
duration = duration - @colorize_step
if duration > 0 do
# then every @colorize_step ms apply color from RGB(5, 5, 0) to RGB(5, 0, 0) (simple gradient from yellow to red)
green = 5 - min(div(floor(duration), @colorize_step), 5)
IO.ANSI.color(5, green, 0)
end
end
end
defp sql_color("SELECT" <> _), do: :cyan
defp sql_color("ROLLBACK" <> _), do: :red
defp sql_color("LOCK" <> _), do: :white
defp sql_color("INSERT" <> _), do: :green
defp sql_color("UPDATE" <> _), do: :yellow
defp sql_color("DELETE" <> _), do: :red
defp sql_color("begin" <> _), do: :magenta
defp sql_color("commit" <> _), do: :magenta
defp sql_color(_), do: :default_color
defp colorize(term, color, return_to_color) do
if IO.ANSI.enabled?() do
[color, term, return_to_color]
else
term
end
end
defp log_stacktrace(stacktrace, repo) do
with [_ | _] <- stacktrace,
{module, function, arity, info} <- last_non_ecto(Enum.reverse(stacktrace), repo, nil) do
[
if(IO.ANSI.enabled?(), do: IO.ANSI.light_black(), else: ""),
?\n,
"↳ ",
Exception.format_mfa(module, function, arity),
log_stacktrace_info(info)
]
else
_ -> []
end
end
defp log_stacktrace_info([file: file, line: line] ++ _) do
[", at: ", file, ?:, Integer.to_string(line)]
end
defp log_stacktrace_info(_) do
[]
end
@repo_modules [Ecto.Repo.Queryable, Ecto.Repo.Schema, Ecto.Repo.Transaction]
defp last_non_ecto([{mod, _, _, _} | _stacktrace], repo, last)
when mod == repo or mod in @repo_modules,
do: last
defp last_non_ecto([last | stacktrace], repo, _last), do: last_non_ecto(stacktrace, repo, last)
defp last_non_ecto([], _repo, last), do: last
end
