Elixir: Audible Loggger

audible_logger.ex

defmodule AudibleLogger do
  @moduledoc """
  A custom Logger backend that can announce when log messages of a minimum level are received. (Tested on macOS)

  Useful to noticing when warnings or errors in your logs.

  ## Configuration

  In `config/dev.exs`
  ```elixir

    config :logger,
    backends: [
      :console,
      {AudibleLogger, :audible_logger}
    ]

  # Will say "warn" or "error" when those logs of those levels are received
  config :logger, :audible_logger, level: :warn
  ```
  """


  # Initialize the configuration
  def init({__MODULE__, name}) do
    {:ok, configure(name, [])}
  end

  # Handle the configuration change call
  def handle_call({:configure, opts}, %{name: name} = state) do
    {:ok, :ok, configure(name, opts, state)}
  end

  # Handle the flush event
  def handle_event(:flush, state) do
    {:ok, state}
  end

  # Handle any log messages that are sent across
  def handle_event(
        {level, _group_leader, {Logger, _message, _timestamp, _metadata}},
        %{level: min_level} = state
      ) do
    if right_log_level?(min_level, level) do
      System.cmd("say", ["#{level}"])
    end

    {:ok, state}
  end

  defp right_log_level?(nil, _level), do: true

  defp right_log_level?(min_level, level) do
    Logger.compare_levels(level, min_level) != :lt
  end

  defp configure(name, []) do
    base_level = Application.get_env(:logger, :level, :debug)
    Application.get_env(:logger, name, []) |> Enum.into(%{name: name, level: base_level})
  end

  defp configure(_name, [level: new_level], state) do
    Map.merge(state, %{level: new_level})
  end

  defp configure(_name, _opts, state), do: state
end