Hackney Librato Metrics

hackney_librarto.ex

defmodule MyApp.Util.HackneyLibratoMetrics do
  require Logger

  def new(_, _) do
    :ok
  end

  def delete(_name) do
    :ok
  end
  def delete(_name, _value) do
    :ok
  end

  @spec increment_counter(any()) :: :ok | {:error, term()}
  def increment_counter(name) do
    increment_counter(name, 1)
  end

  @spec increment_counter(any(), pos_integer()) ::  :ok | {:error, term()}
  def increment_counter(name, value) do
    log(:count, name, value)
  end

  @spec decrement_counter(any()) ::  :ok | {:error, term()}
  def decrement_counter(name) do
    log(:count, name, -1)
  end

  @spec decrement_counter(any(), pos_integer()) ::  :ok | {:error, term()}
  def decrement_counter(name, value) do
    log(:count, name, -value)
  end

  def update_histogram(name, fun) when is_function(fun, 0) do
    begin = :os.timestamp()
    result = fun.()
    duration = div(:timer.now_diff(:os.timestamp(), begin), 1000)
    log(:measure, name, [:io_lib_format.fwrite_g(duration), ?m, ?s])
    result
  end

  def update_histogram(name, value) when is_number(value) do
    log(:measure, name, value)
  end

  @spec update_gauge(any(), number()) ::  :ok | {:error, term()}
  def update_gauge(name, value) do
    log(:sample, name, value)
  end

  @spec update_meter(any(), number()) ::  :ok | {:error, term()}
  def update_meter(name, value) do
    log(:sample, name, value)
  end

   @spec notify(any(), any(), atom()) ::  :ok | {:error, term()}
   def notify(_name, _value, _op) do
     :ok
   end

   defp name(name) when is_list(name) do
     Enum.map(name, fn (key) when is_atom(key) -> Atom.to_string(key)
                       (key) -> key end)
     |> Enum.intersperse(?.)
   end
   defp name(name) when is_binary(name), do: name

   defp log(op, name, value) when is_integer(value) do
     log(op, name, Integer.to_string(value))
   end

   defp log(op, name, value) when is_float(value) do
     log(op, name, [:io_lib_format.fwrite_g(value), ?m, ?s])
   end
   defp log(op, name, value) do
      key = [[Atom.to_string(op), ?#], name(name)]
      log(key, value)
   end
   defp log(key, value) do
    Logger.info(fn ->
      [key, ?=, value]
    end)
    :ok
   end
end