You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
187 lines
5.8 KiB
Elixir
187 lines
5.8 KiB
Elixir
defmodule Plausible.Stats.Aggregate do
|
|
alias Plausible.Stats.Query
|
|
use Plausible.ClickhouseRepo
|
|
import Plausible.Stats.{Base, Imported, Util}
|
|
import Ecto.Query
|
|
|
|
@event_metrics [
|
|
:visitors,
|
|
:pageviews,
|
|
:events,
|
|
:sample_percent,
|
|
:average_revenue,
|
|
:total_revenue
|
|
]
|
|
@session_metrics [:visits, :bounce_rate, :visit_duration, :views_per_visit, :sample_percent]
|
|
@revenue_metrics [:average_revenue, :total_revenue]
|
|
|
|
def aggregate(site, query, metrics) do
|
|
# Aggregating revenue data works only for same currency goals. If the query
|
|
# is filtered by goals with different currencies, for example, one USD and
|
|
# other EUR, revenue metrics are dropped.
|
|
currency = get_revenue_tracking_currency(site, query, metrics)
|
|
metrics = if currency, do: metrics, else: metrics -- @revenue_metrics
|
|
|
|
event_metrics = Enum.filter(metrics, &(&1 in @event_metrics))
|
|
event_task = fn -> aggregate_events(site, query, event_metrics) end
|
|
session_metrics = Enum.filter(metrics, &(&1 in @session_metrics))
|
|
session_task = fn -> aggregate_sessions(site, query, session_metrics) end
|
|
|
|
time_on_page_task =
|
|
if :time_on_page in metrics do
|
|
fn -> aggregate_time_on_page(site, query) end
|
|
else
|
|
fn -> %{} end
|
|
end
|
|
|
|
Plausible.ClickhouseRepo.parallel_tasks([session_task, event_task, time_on_page_task])
|
|
|> Enum.reduce(%{}, fn aggregate, task_result -> Map.merge(aggregate, task_result) end)
|
|
|> Enum.map(&maybe_round_value/1)
|
|
|> Enum.map(&cast_revenue_metric_to_money(&1, currency))
|
|
|> Enum.map(fn {metric, value} -> {metric, %{value: value}} end)
|
|
|> Enum.into(%{})
|
|
end
|
|
|
|
defp aggregate_events(_, _, []), do: %{}
|
|
|
|
defp aggregate_events(site, query, metrics) do
|
|
from(e in base_event_query(site, query), select: %{})
|
|
|> select_event_metrics(metrics)
|
|
|> merge_imported(site, query, :aggregate, metrics)
|
|
|> ClickhouseRepo.one()
|
|
end
|
|
|
|
defp aggregate_sessions(_, _, []), do: %{}
|
|
|
|
defp aggregate_sessions(site, query, metrics) do
|
|
from(e in query_sessions(site, query), select: %{})
|
|
|> filter_converted_sessions(site, query)
|
|
|> select_session_metrics(metrics, query)
|
|
|> merge_imported(site, query, :aggregate, metrics)
|
|
|> ClickhouseRepo.one()
|
|
|> remove_internal_visits_metric()
|
|
end
|
|
|
|
defp aggregate_time_on_page(site, query) do
|
|
q =
|
|
from(
|
|
e in base_event_query(site, %Query{
|
|
query
|
|
| filters: Map.delete(query.filters, "event:page")
|
|
}),
|
|
select: {
|
|
fragment("? as p", e.pathname),
|
|
fragment("? as t", e.timestamp),
|
|
fragment("? as s", e.session_id)
|
|
},
|
|
order_by: [e.session_id, e.timestamp]
|
|
)
|
|
|
|
{base_query_raw, base_query_raw_params} = ClickhouseRepo.to_sql(:all, q)
|
|
where_param_idx = length(base_query_raw_params)
|
|
|
|
{where_clause, where_arg} =
|
|
case query.filters["event:page"] do
|
|
{:is, page} ->
|
|
{"p = {$#{where_param_idx}:String}", page}
|
|
|
|
{:is_not, page} ->
|
|
{"p != {$#{where_param_idx}:String}", page}
|
|
|
|
{:member, page} ->
|
|
{"p IN {$#{where_param_idx}:Array(String)}", page}
|
|
|
|
{:not_member, page} ->
|
|
{"p NOT IN {$#{where_param_idx}:Array(String)}", page}
|
|
|
|
{:matches, expr} ->
|
|
regex = page_regex(expr)
|
|
{"match(p, {$#{where_param_idx}:String})", regex}
|
|
|
|
{:matches_member, exprs} ->
|
|
page_regexes = Enum.map(exprs, &page_regex/1)
|
|
{"multiMatchAny(p, {$#{where_param_idx}:Array(String)})", page_regexes}
|
|
|
|
{:not_matches_member, exprs} ->
|
|
page_regexes = Enum.map(exprs, &page_regex/1)
|
|
{"not(multiMatchAny(p, {$#{where_param_idx}:Array(String)}))", page_regexes}
|
|
|
|
{:does_not_match, expr} ->
|
|
regex = page_regex(expr)
|
|
{"not(match(p, {$#{where_param_idx}:String}))", regex}
|
|
end
|
|
|
|
params = base_query_raw_params ++ [where_arg]
|
|
|
|
time_query = "
|
|
SELECT
|
|
avg(ifNotFinite(avgTime, null))
|
|
FROM
|
|
(SELECT
|
|
p,
|
|
sum(td)/count(case when p2 != p then 1 end) as avgTime
|
|
FROM
|
|
(SELECT
|
|
p,
|
|
p2,
|
|
sum(t2-t) as td
|
|
FROM
|
|
(SELECT
|
|
*,
|
|
neighbor(t, 1) as t2,
|
|
neighbor(p, 1) as p2,
|
|
neighbor(s, 1) as s2
|
|
FROM (#{base_query_raw}))
|
|
WHERE s=s2 AND #{where_clause}
|
|
GROUP BY p,p2,s)
|
|
GROUP BY p)"
|
|
|
|
{:ok, res} = ClickhouseRepo.query(time_query, params)
|
|
[[time_on_page]] = res.rows
|
|
%{time_on_page: time_on_page}
|
|
end
|
|
|
|
@metrics_to_round [:bounce_rate, :time_on_page, :visit_duration, :sample_percent]
|
|
|
|
defp maybe_round_value({metric, nil}), do: {metric, 0}
|
|
|
|
defp maybe_round_value({metric, value}) when metric in @metrics_to_round do
|
|
{metric, round(value)}
|
|
end
|
|
|
|
defp maybe_round_value(entry), do: entry
|
|
|
|
defp get_revenue_tracking_currency(site, query, metrics) do
|
|
goal_filters =
|
|
case query.filters do
|
|
%{"event:goal" => {:is, {_, goal_name}}} -> [goal_name]
|
|
%{"event:goal" => {:member, list}} -> Enum.map(list, fn {_, goal_name} -> goal_name end)
|
|
_any -> []
|
|
end
|
|
|
|
if Enum.any?(metrics, &(&1 in @revenue_metrics)) && Enum.any?(goal_filters) do
|
|
revenue_goals_currencies =
|
|
Plausible.Repo.all(
|
|
from rg in assoc(site, :revenue_goals),
|
|
where: rg.event_name in ^goal_filters,
|
|
select: rg.currency,
|
|
distinct: true
|
|
)
|
|
|
|
if length(revenue_goals_currencies) == 1,
|
|
do: List.first(revenue_goals_currencies),
|
|
else: nil
|
|
else
|
|
nil
|
|
end
|
|
end
|
|
|
|
defp cast_revenue_metric_to_money({metric, value}, currency) do
|
|
if metric in @revenue_metrics and is_atom(currency) do
|
|
{metric, Money.new!(value, currency)}
|
|
else
|
|
{metric, value}
|
|
end
|
|
end
|
|
end
|