Base implementation of formatter and translator

Author: sorentwo

.formatter.exs

@@ -1,4 +1,5 @@
 # Used by "mix format"
 [
+  import_deps: [:stream_data],
   inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
 ]

lib/medea.ex

@@ -0,0 +1,32 @@
+defmodule Medea.Formatter do
+  @moduledoc """
+  A formatter for JSON logs.
+  """
+
+  import Jason.Helpers, only: [json_map: 1]
+
+  alias Medea.Utils
+
+  @type time :: Logger.Formatter.time()
+
+  @doc """
+  Format messages into structured JSON logs.
+  """
+  @spec format(Logger.level(), Logger.message(), time(), keyword()) :: IO.chardata()
+  def format(level, message, time, metadata) do
+    [level: level, time: format_time(time), message: message, metadata: Utils.clean(metadata)]
+    |> json_map()
+    |> Jason.encode_to_iodata!()
+  rescue
+    exception ->
+      reason = Exception.format_banner(:error, exception)
+
+      [~s({"error":"could not log '), inspect(message), "' because: ", reason, ~s("})]
+  end
+
+  defp format_time({date, {h, m, s, ms}}) do
+    {date, {h, m, s}}
+    |> NaiveDateTime.from_erl!({ms, 3})
+    |> NaiveDateTime.to_string()
+  end
+end

lib/medea/formatter.ex

@@ -0,0 +1,32 @@
+defmodule Medea.Translator do
+  @moduledoc """
+  Translates structured log "reports" into encoded JSON iodata.
+  """
+
+  alias Medea.Utils
+
+  @type kind :: :format | :report
+  @type level :: Logger.level()
+  @type report :: :logger.report()
+
+  @type result ::
+          {:ok, iodata(), keyword()}
+          | {:ok, iodata()}
+          | :skip
+          | :none
+
+  @doc """
+  Translate a report into encoded JSON iodata or fall through to the default translator.
+  """
+  @spec translate(level(), level(), kind(), report()) :: result()
+  def translate(_min, _level, :report, {:logger, message}) do
+    encoded =
+      message
+      |> Utils.clean()
+      |> Jason.encode!()
+
+    {:ok, encoded}
+  end
+
+  def translate(_min_lev, _level, _kind, _message), do: :none
+end

lib/medea/translator.ex

@@ -0,0 +1,39 @@
+defmodule Medea.Utils do
+  @moduledoc false
+
+  def clean(%Date{} = date), do: date
+  def clean(%DateTime{} = datetime), do: datetime
+  def clean(%NaiveDateTime{} = naive), do: naive
+  def clean(%Time{} = time), do: time
+
+  def clean(%_{} = struct) do
+    struct
+    |> Map.from_struct()
+    |> clean()
+  end
+
+  def clean(map) when is_map(map) do
+    for {key, val} <- map, into: %{}, do: {clean(key), clean(val)}
+  end
+
+  def clean([{key, _val} | _] = keyword) when is_atom(key) do
+    keyword
+    |> Map.new()
+    |> clean()
+  end
+
+  def clean(list) when is_list(list) do
+    for elem <- list, do: clean(elem)
+  end
+
+  def clean(tuple) when is_tuple(tuple) do
+    tuple
+    |> Tuple.to_list()
+    |> clean
+  end
+
+  def clean(binary) when is_binary(binary), do: Logger.Formatter.prune(binary)
+  def clean(term) when is_pid(term) or is_reference(term), do: inspect(term)
+  def clean(term) when is_port(term) or is_function(term), do: inspect(term)
+  def clean(term), do: term
+end

lib/medea/utils.ex

@@ -18,7 +18,7 @@ defmodule Medea.MixProject do
   defp deps do
     [
       {:jason, "~> 1.4"},
-      {:stream_data, "~> 0.5", only: [:test]}
+      {:stream_data, "~> 0.5", only: [:dev, :test]}
     ]
   end
 end

mix.exs

@@ -0,0 +1,59 @@
+defmodule Medea.FormatterTest do
+  use ExUnit.Case, async: true
+
+  use ExUnitProperties
+
+  alias Medea.Formatter
+
+  @datetime {{2022, 10, 06}, {16, 38, 00, 120}}
+
+  defp format(level, message, time, metadata \\ []) do
+    level
+    |> Formatter.format(message, time, metadata)
+    |> IO.iodata_to_binary()
+    |> Jason.decode!()
+  end
+
+  describe "format/4" do
+    property "encoding any messages as json iodata" do
+      check all level <- level(), time <- datetime(), message <- message() do
+        decoded = format(level, message, time)
+
+        assert %{"level" => _, "time" => _, "message" => _} = decoded
+      end
+    end
+
+    test "formatting log datetimes" do
+      assert %{"time" => "2022-10-06 16:38:00.000"} = format(:info, "boop", @datetime)
+    end
+
+    test "formatting log metadata" do
+      metadata = [user_id: 1, admin: true, thing: {:a, :b}]
+
+      assert %{"metadata" => meta} = format(:info, "boop", @datetime, metadata)
+      assert %{"user_id" => 1, "admin" => true, "thing" => ["a", "b"]} = meta
+    end
+
+    test "reporting logging errors" do
+      assert %{"error" => error} = format(:info, {:error, :broken}, @datetime)
+
+      assert error =~ "could not log '{:error, :broken}'"
+    end
+  end
+
+  defp level, do: one_of([:alert, :error, :warning, :notice])
+
+  defp message, do: string(:ascii)
+
+  defp datetime do
+    gen all year <- integer(1977..2022),
+            month <- integer(1..12),
+            day <- integer(1..28),
+            hour <- integer(0..23),
+            minute <- integer(0..59),
+            second <- integer(0..59),
+            ms <- integer(1..9999) do
+      {{year, month, day}, {hour, minute, second, ms}}
+    end
+  end
+end

test/medea/formatter_test.exs

@@ -0,0 +1,35 @@
+defmodule Medea.TranslatorTest do
+  use ExUnit.Case, async: true
+
+  use ExUnitProperties
+
+  alias Medea.Translator
+
+  describe "translate/4" do
+    property "all terms are safely encoded to iodata" do
+      check all message <- message() do
+        assert {:ok, iodata} = Translator.translate(:info, :info, :report, {:logger, message})
+
+        assert is_binary(iodata)
+      end
+    end
+
+    test "all non-logger formats or reports are ignored" do
+      assert :none = Translator.translate(:info, :info, :report, {:not, :from, :logger})
+    end
+  end
+
+  defp message do
+    one_of([
+      atom(:alphanumeric),
+      binary(),
+      tuple({key(), val()}),
+      map_of(key(), val()),
+      keyword_of(val())
+    ])
+  end
+
+  defp key, do: one_of([atom(:alphanumeric), string(:ascii)])
+
+  defp val, do: one_of([atom(:alphanumeric), map_of(key(), key())])
+end