defmodule Wobserver.Util.Metrics.Formatter do
@moduledoc ~S"""
Formatter.
"""
alias Wobserver.Util.Node.Discovery
@doc ~S"""
Format a set of `data` with a `label`.
The `data` must be given as a `list` of tuples with the following format: `{value, labels}`, where `labels` is a keyword list with labels and their values.
The following options can also be given:
- `type`, the type of the metric. The following values are currently supported: `:gauge`, `:counter`.
- `help`, a single line text description of the metric.
"""
@callback format_data(
name :: String.t,
data :: [{integer | float, keyword}],
type :: :atom,
help :: String.t
) :: String.t
@doc ~S"""
Combines formatted metrics together.
Arguments:
- `metrics`, a list of formatted metrics for one node.
"""
@callback combine_metrics(
metrics :: list[String.t]
) :: String.t
@doc ~S"""
Merges formatted sets of metrics from different nodes together.
The merge should prevent double declarations of help and type.
Arguments:
- `metrics`, a list of formatted sets metrics for multiple node.
"""
@callback merge_metrics(
metrics :: list[String.t]
) :: String.t
@doc ~S"""
Format a set of `data` with a `label` for a metric parser/aggregater.
The following options can also be given:
- `type`, the type of the metric. The following values are currently supported: `:gauge`, `:counter`.
- `help`, a single line text description of the metric.
- `formatter`, a module implementing the `Formatter` behaviour to format metrics.
"""
@spec format(
data :: any,
label :: String.t,
type :: :gauge | :counter | nil,
help :: String.t | nil,
formatter :: atom | nil
) :: String.t | :error
def format(data, label, type \\ nil, help \\ nil, formatter \\ nil)
def format(data, label, type, help, nil) do
format(data, label, type, help, Application.get_env(
:wobserver,
:metric_format,
Wobserver.Util.Metrics.Prometheus
))
end
def format(data, label, type, help, formatter) when is_binary(formatter) do
{new_formatter, []} = Code.eval_string formatter
format(data, label, type, help, new_formatter)
end
def format(data, label, type, help, formatter)
when is_integer(data) or is_float(data) do
format([{data, []}], label, type, help, formatter)
end
def format(data, label, type, help, formatter) when is_map(data) do
data
|> map_to_data()
|> format(label, type, help, formatter)
end
def format(data, label, type, help, formatter) when is_binary(data) do
{new_data, []} = Code.eval_string data
format(new_data, label, type, help, formatter)
catch
:error, _ -> :error
end
def format(data, label, type, help, formatter) when is_function(data) do
data.()
|> format(label, type, help, formatter)
end
def format(data, label, type, help, formatter) do
cond do
Keyword.keyword?(data) ->
data
|> list_to_data()
|> format(label, type, help, formatter)
is_list(data) ->
data =
data
|> Enum.map(fn {value, labels} ->
{value, Keyword.merge([node: Discovery.local.name], labels)}
end)
formatter.format_data(label, data, type, help)
true ->
:error
end
end
@doc ~S"""
Formats a keyword list of metrics using a given `formatter`.
**Metrics**
The key is the name of the metric and the value can be given in the following formats:
- `data`
- `{data, type}`
- `{data, type, help}`
The different fields are:
- `data`, the actual metrics information.
- `type`, the type of the metric.
Possible values: `:gauge`, `:counter`.
- `help`, a one line text description of the metric.
The `data` can be given in the following formats:
- `integer` | `float`, just a single value.
- `map`, where every key will be turned into a type value.
- `keyword` list, where every key will be turned into a type value
- `list` of tuples with the following format: `{value, labels}`, where `labels` is a keyword list with labels and their values.
- `function` | `string`, a function or String that can be evaluated to a function, which, when called, returns one of the above data-types.
Example:
```elixir
iex> Wobserver.Util.Metrics.Formatter.format_all [simple: 5]
"simple{node=\"10.74.181.35\"} 5\n"
```
```elixir
iex> Wobserver.Util.Metrics.Formatter.format_all [simple: {5, :gauge}]
"# TYPE simple gauge\nsimple{node=\"10.74.181.35\"} 5\n"
```
```elixir
iex> Wobserver.Util.Metrics.Formatter.format_all [simple: {5, :gauge, "Example desc."}]
"# HELP simple Example desc.\n
# TYPE simple gauge\n
simple{node=\"10.74.181.35\"} 5\n"
```
```elixir
iex> Wobserver.Util.Metrics.Formatter.format_all [simple: %{floor: 5, wall: 8}]
"simple{node=\"10.74.181.35\",type=\"floor\"} 5\n
simple{node=\"10.74.181.35\",type=\"wall\"} 8\n"
```
```elixir
iex> Wobserver.Util.Metrics.Formatter.format_all [simple: [floor: 5, wall: 8]]
"simple{node=\"10.74.181.35\",type=\"floor\"} 5\n
simple{node=\"10.74.181.35\",type=\"wall\"} 8\n"
```
```elixir
iex> Wobserver.Util.Metrics.Formatter.format_all [simple: [{5, [location: :floor]}, {8, [location: :wall]}]]
"simple{node=\"10.74.181.35\",location=\"floor\"} 5\n
simple{node=\"10.74.181.35\",location=\"wall\"} 8\n"
```
"""
@spec format_all(data :: list, formatter :: atom) :: String.t | :error
def format_all(data, formatter \\ nil)
def format_all(data, nil) do
format_all(data, Application.get_env(
:wobserver,
:metric_format,
Wobserver.Util.Metrics.Prometheus
))
end
def format_all(data, formatter) do
formatted =
data
|> Enum.map(&helper(&1, formatter))
case Enum.member?(formatted, :error) do
true -> :error
_ -> formatted |> formatter.combine_metrics
end
end
@doc ~S"""
Merges formatted sets of metrics from different nodes together using a given `formatter`.
The merge should prevent double declarations of help and type.
Arguments:
- `metrics`, a list of formatted sets metrics for multiple node.
"""
@spec merge_metrics(metrics :: list(String.t), formatter :: atom)
:: String.t | :error
def merge_metrics(metrics, formatter \\ nil)
def merge_metrics(metrics, nil) do
merge_metrics(metrics,
Application.get_env(
:wobserver,
:metric_format,
Wobserver.Util.Metrics.Prometheus
)
)
end
def merge_metrics(metrics, formatter) do
# Old way: One node error, means no metrics
#
# case Enum.member?(metrics, :error) do
# true -> :error
# false -> formatter.merge_metrics(metrics)
# end
metrics
|> Enum.filter(fn m -> m != :error end)
|> formatter.merge_metrics
end
# Helpers
defp helper({key, {data, type, help}}, formatter) do
format(data, Atom.to_string(key), type, help, formatter)
end
defp helper({key, {data, type}}, formatter) do
format(data, Atom.to_string(key), type, nil, formatter)
end
defp helper({key, data}, formatter) do
format(data, Atom.to_string(key), nil, nil, formatter)
end
defp map_to_data(map) do
map
|> Map.to_list
|> Enum.filter(fn {a, _} -> a != :__struct__ && a != :total end)
|> list_to_data()
end
defp list_to_data(list) do
list
|> Enum.map(fn {key, value} -> {value, [type: key]} end)
end
end
