Format code using the Elixir's formatter (#27)

.formatter.exs

@@ -0,0 +1,3 @@
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

config/config.exs

@@ -29,4 +29,4 @@ use Mix.Config
 #
 #     import_config "#{Mix.env}.exs"
 
-import_config "#{Mix.env}.exs"
+import_config "#{Mix.env()}.exs"

config/dev.exs

@@ -5,5 +5,4 @@ config :logger,
     {LogstashJson.Console, :json}
   ]
 
-config :logger, :json,
-  level: :info
+config :logger, :json, level: :info

config/prod.exs

@@ -14,5 +14,4 @@ config :logger, :logstash,
   workers: 2,
   buffer_size: 10_000
 
-config :logger, :json,
-  level: :info
+config :logger, :json, level: :info

config/test.exs

@@ -5,8 +5,7 @@ config :logger,
     {LogstashJson.Console, :json}
   ]
 
-config :logger, :json,
-  level: :info
+config :logger, :json, level: :info
 
 config :logger, :logstash,
   level: :debug,
@@ -21,4 +20,4 @@ config :logger, :logstash_with_formatter,
   fields: %{appid: "logstash-json"},
   workers: 1,
   buffer_size: 10_000,
-  formatter: fn (event) -> event |> Map.put(:added_by_formatter, "I am extra") end
+  formatter: fn event -> event |> Map.put(:added_by_formatter, "I am extra") end

lib/connection/tcp.ex

@@ -33,28 +33,26 @@ defmodule LogstashJson.TCP.Connection do
   def init({host, port, queue, id, timeout}) do
     LogstashJson.TCP.Connection.Worker.start_link(self(), queue)
 
-    state = %{
-      id: id,
-      host: host,
-      port: port,
-      timeout: timeout,
-      sock: nil}
+    state = %{id: id, host: host, port: port, timeout: timeout, sock: nil}
     {:connect, :init, state}
   end
 
   def connect(:init, %{id: id, sock: nil, host: host, port: port, timeout: timeout} = state) do
     case :gen_tcp.connect(host, port, @connection_opts, timeout) do
       {:ok, sock} ->
         {:ok, %{state | sock: sock}}
+
       {:error, reason} ->
         connect_error_log(id, reason, host, port)
         {:backoff, @backoff_ms, state}
     end
   end
+
   def connect(_info, %{sock: nil, host: host, port: port, timeout: timeout} = state) do
     case :gen_tcp.connect(host, port, @connection_opts, timeout) do
       {:ok, sock} ->
         {:ok, %{state | sock: sock}}
+
       {:error, _reason} ->
         {:backoff, @backoff_ms, state}
     end
@@ -64,10 +62,12 @@ defmodule LogstashJson.TCP.Connection do
     if sock != nil do
       :ok = :gen_tcp.close(sock)
     end
+
     case info do
       {:close, from} -> Connection.reply(from, :ok)
       {:error, reason} -> disconnect_error_log(id, reason, host, port)
     end
+
     {:backoff, @backoff_ms, %{state | sock: nil}}
   end
 
@@ -80,8 +80,10 @@ defmodule LogstashJson.TCP.Connection do
     case :gen_tcp.send(sock, data) do
       :ok ->
         {:reply, :ok, state}
+
       {:error, :closed} = error ->
         {:disconnect, error, error, state}
+
       {:error, reason} = error ->
         send_error_log(id, reason)
         {:disconnect, error, error, state}
@@ -93,9 +95,7 @@ defmodule LogstashJson.TCP.Connection do
   end
 
   def handle_call({:configure, host, port}, from, state) do
-    {:disconnect, {:close, from}, %{state |
-      host: host,
-      port: port}}
+    {:disconnect, {:close, from}, %{state | host: host, port: port}}
   end
 
   def terminate(_, %{sock: sock}) do
@@ -106,18 +106,21 @@ defmodule LogstashJson.TCP.Connection do
 
   defp connect_error_log(id, reason, host, port) do
     reason = :inet.format_error(reason)
-    IO.puts "#{__MODULE__}[#{id}]: #{host}:#{inspect port} connection failed: #{reason}"
+    IO.puts("#{__MODULE__}[#{id}]: #{host}:#{inspect(port)} connection failed: #{reason}")
   end
+
   defp disconnect_error_log(id, :closed, host, port) do
-    IO.puts "#{__MODULE__}[#{id}]: #{host}:#{inspect port} connection closed"
+    IO.puts("#{__MODULE__}[#{id}]: #{host}:#{inspect(port)} connection closed")
   end
+
   defp disconnect_error_log(id, reason, host, port) do
     reason = :inet.format_error(reason)
-    IO.puts "#{__MODULE__}[#{id}]: #{host}:#{inspect port} connection error: #{reason}"
+    IO.puts("#{__MODULE__}[#{id}]: #{host}:#{inspect(port)} connection error: #{reason}")
   end
+
   defp send_error_log(id, reason) do
     reason = :inet.format_error(reason)
-    IO.puts "#{__MODULE__}[#{id}]: error sending over TCP: #{reason}"
+    IO.puts("#{__MODULE__}[#{id}]: error sending over TCP: #{reason}")
   end
 end
 
@@ -128,7 +131,7 @@ defmodule LogstashJson.TCP.Connection.Worker do
   """
 
   def start_link(conn, queue) do
-    spawn_link fn -> consume_messages(conn, queue) end
+    spawn_link(fn -> consume_messages(conn, queue) end)
   end
 
   defp consume_messages(conn, queue) do

lib/logstash_json/event.ex

@@ -1,5 +1,4 @@
 defmodule LogstashJson.Event do
-
   @moduledoc """
   This module contains functions for generating and serializing logs events.
   """
@@ -8,13 +7,13 @@ defmodule LogstashJson.Event do
   def event(level, msg, ts, md, %{fields: fields, utc_log: utc_log, formatter: formatter}) do
     fields
     |> format_fields(md, %{
-          "@timestamp": timestamp(ts, utc_log),
-          level: level,
-          message: to_string(msg),
-          module: md[:module],
-          function: md[:function],
-          line: md[:line]
-       })
+      "@timestamp": timestamp(ts, utc_log),
+      level: level,
+      message: to_string(msg),
+      module: md[:module],
+      function: md[:function],
+      line: md[:line]
+    })
     |> formatter.()
   end
 
@@ -35,7 +34,7 @@ defmodule LogstashJson.Event do
     |> Enum.into(%{})
   end
 
-  def resolve_formatter_config(formatter_spec, default_formatter \\ &(&1)) do
+  def resolve_formatter_config(formatter_spec, default_formatter \\ & &1) do
     # Find an appropriate formatter, if possible, from this config spec.
     case formatter_spec do
       {module, function} ->
@@ -44,10 +43,13 @@ defmodule LogstashJson.Event do
         else
           {:error, {module, function}}
         end
+
       fun when is_function(fun) ->
         {:ok, fun}
+
       nil ->
         {:ok, default_formatter}
+
       bad_formatter ->
         {:error, bad_formatter}
     end
@@ -69,7 +71,7 @@ defmodule LogstashJson.Event do
   defp timezone() do
     offset = timezone_offset()
     minute = offset |> abs() |> rem(3600) |> div(60)
-    hour   = offset |> abs() |> div(3600)
+    hour = offset |> abs() |> div(3600)
     sign(offset) <> zero_pad(hour, 2) <> ":" <> zero_pad(minute, 2)
   end
 
@@ -84,26 +86,30 @@ defmodule LogstashJson.Event do
   end
 
   defp sign(total) when total < 0, do: "-"
-  defp sign(_),                    do: "+"
+  defp sign(_), do: "+"
 
   defp zero_pad(val, count) do
     num = Integer.to_string(val)
     :binary.copy("0", count - byte_size(num)) <> num
   end
 
   # Traverse complex objects and inspect PID's to their string representation
-  defp print_pids(it) when is_pid(it),   do: inspect(it)
-  defp print_pids(it) when is_list(it),  do: Enum.map it, &print_pids/1
+  defp print_pids(it) when is_pid(it), do: inspect(it)
+  defp print_pids(it) when is_list(it), do: Enum.map(it, &print_pids/1)
   defp print_pids(it) when is_tuple(it), do: print_pids(Tuple.to_list(it))
-  defp print_pids(%_{} = it),            do: print_pids(Map.from_struct(it))
-  defp print_pids(it) when is_map(it),   do: Enum.into(it, %{}, fn {k, v} -> {print_pids(k), print_pids(v)} end)
+  defp print_pids(%_{} = it), do: print_pids(Map.from_struct(it))
+
+  defp print_pids(it) when is_map(it),
+    do: Enum.into(it, %{}, fn {k, v} -> {print_pids(k), print_pids(v)} end)
+
   defp print_pids(it) when is_binary(it) do
     it
-    |> String.valid?
+    |> String.valid?()
     |> case do
       true -> it
       false -> inspect(it)
     end
   end
+
   defp print_pids(it), do: it
 end

lib/logstash_json_console.ex

@@ -28,6 +28,7 @@ defmodule LogstashJson.Console do
     if is_nil(min_level) or Logger.compare_levels(level, min_level) != :lt do
       log_event(level, msg, ts, md, state)
     end
+
     {:ok, state}
   end
 
@@ -52,27 +53,31 @@ defmodule LogstashJson.Console do
     opts = Keyword.merge(env, opts)
     Application.put_env(:logger, name, opts)
 
-    level    = Keyword.get(opts, :level)
-    fields   = Keyword.get(opts, :fields) || %{}
-    utc_log  = Application.get_env(:logger, :utc_log, false)
-    formatter   =
+    level = Keyword.get(opts, :level)
+    fields = Keyword.get(opts, :fields) || %{}
+    utc_log = Application.get_env(:logger, :utc_log, false)
+
+    formatter =
       case LogstashJson.Event.resolve_formatter_config(Keyword.get(opts, :formatter)) do
         {:ok, fun} ->
           fun
+
         {:error, bad_formatter} ->
-          raise "Bad formatter configured for :logger, #{name} -- #{inspect bad_formatter}"
+          raise "Bad formatter configured for :logger, #{name} -- #{inspect(bad_formatter)}"
       end
 
     %{level: level, fields: fields, utc_log: utc_log, formatter: formatter}
   end
 
   defp log_event(level, msg, ts, md, state) do
     event = LogstashJson.Event.event(level, msg, ts, md, state)
+
     case LogstashJson.Event.json(event) do
       {:ok, log} ->
-        IO.puts log
+        IO.puts(log)
+
       {:error, reason} ->
-        IO.puts "Failed to serialize event. error: #{inspect reason}, event: #{inspect event}"
+        IO.puts("Failed to serialize event. error: #{inspect(reason)}, event: #{inspect(event)}")
     end
   end
 end

lib/logstash_json_tcp.ex

@@ -37,6 +37,7 @@ defmodule LogstashJson.TCP do
     if is_nil(min_level) or Logger.compare_levels(level, min_level) != :lt do
       log_event(level, msg, ts, md, state)
     end
+
     {:ok, state}
   end
 
@@ -52,11 +53,13 @@ defmodule LogstashJson.TCP do
 
   defp log_event(level, msg, ts, md, state) do
     event = LogstashJson.Event.event(level, msg, ts, md, state)
+
     case LogstashJson.Event.json(event) do
       {:ok, log} ->
         send_log(log, state)
+
       {:error, reason} ->
-        IO.puts "Failed to serialize event. error: #{reason}, event: #{inspect event}"
+        IO.puts("Failed to serialize event. error: #{reason}, event: #{inspect(event)}")
     end
   end
 
@@ -69,20 +72,22 @@ defmodule LogstashJson.TCP do
     opts = Keyword.merge(env, opts)
     Application.put_env(:logger, name, opts)
 
-    level       = Keyword.get(opts, :level) || :debug
-    host        = opts |> Keyword.get(:host) |> env_var |> to_charlist
-    port        = opts |> Keyword.get(:port) |> env_var |> to_int
-    fields      = Keyword.get(opts, :fields) || %{}
-    workers     = Keyword.get(opts, :workers) || 2
+    level = Keyword.get(opts, :level) || :debug
+    host = opts |> Keyword.get(:host) |> env_var |> to_charlist
+    port = opts |> Keyword.get(:port) |> env_var |> to_int
+    fields = Keyword.get(opts, :fields) || %{}
+    workers = Keyword.get(opts, :workers) || 2
     worker_pool = Keyword.get(opts, :worker_pool) || nil
     buffer_size = Keyword.get(opts, :buffer_size) || 10_000
-    utc_log     = Application.get_env(:logger, :utc_log, false)
-    formatter   =
+    utc_log = Application.get_env(:logger, :utc_log, false)
+
+    formatter =
       case LogstashJson.Event.resolve_formatter_config(Keyword.get(opts, :formatter)) do
         {:ok, fun} ->
           fun
+
         {:error, bad_formatter} ->
-          raise "Bad formatter configured for :logger, #{name} -- #{inspect bad_formatter}"
+          raise "Bad formatter configured for :logger, #{name} -- #{inspect(bad_formatter)}"
       end
 
     # Close previous worker pool
@@ -93,26 +98,28 @@ defmodule LogstashJson.TCP do
     # Create new queue and worker pool
     {:ok, queue} = BlockingQueue.start_link(buffer_size)
 
-    children = 1..workers |> Enum.map(& tcp_worker(&1, host, port, queue))
-    {:ok, worker_pool} = Supervisor.start_link(children, [strategy: :one_for_one])
+    children = 1..workers |> Enum.map(&tcp_worker(&1, host, port, queue))
+    {:ok, worker_pool} = Supervisor.start_link(children, strategy: :one_for_one)
 
-    %{level: level,
+    %{
+      level: level,
       host: host,
       port: port,
       fields: fields,
       name: name,
       queue: queue,
       worker_pool: worker_pool,
       formatter: formatter,
-      utc_log: utc_log}
+      utc_log: utc_log
+    }
   end
 
   defp env_var({:system, var, default}), do: System.get_env(var) || default
   defp env_var({:system, var}), do: System.get_env(var)
   defp env_var(value), do: value
 
   defp to_int(val) when is_integer(val), do: val
-  defp to_int(val), do: val |> Integer.parse |> elem(0)
+  defp to_int(val), do: val |> Integer.parse() |> elem(0)
 
   defp tcp_worker(id, host, port, queue) do
     worker(TCP.Connection, [host, port, queue, id], id: id)

mix.exs

@@ -8,8 +8,8 @@ defmodule LogstashJson.Mixfile do
       elixir: "~> 1.4",
       description: description(),
       package: package(),
-      build_embedded: Mix.env == :prod,
-      start_permanent: Mix.env == :prod,
+      build_embedded: Mix.env() == :prod,
+      start_permanent: Mix.env() == :prod,
       deps: deps()
     ]
   end
@@ -39,7 +39,7 @@ defmodule LogstashJson.Mixfile do
       name: :logstash_json,
       maintainers: ["Tobias Ara Svensson"],
       licenses: ["MIT"],
-      links: %{"Github" => "https://github.com/svetob/logstash-json"},
+      links: %{"Github" => "https://github.com/svetob/logstash-json"}
     ]
   end
 end