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.
155 lines
4.8 KiB
Elixir
155 lines
4.8 KiB
Elixir
defmodule Plausible.Session.Store do
|
|
use GenServer
|
|
use Plausible.Repo
|
|
import Ecto.Query, only: [from: 2]
|
|
require Logger
|
|
|
|
@garbage_collect_interval_milliseconds 60 * 1000
|
|
|
|
def start_link(opts) do
|
|
GenServer.start_link(__MODULE__, opts, name: __MODULE__)
|
|
end
|
|
|
|
def init(opts) do
|
|
buffer = Keyword.get(opts, :buffer, Plausible.Session.WriteBuffer)
|
|
timer = Process.send_after(self(), :garbage_collect, @garbage_collect_interval_milliseconds)
|
|
|
|
latest_sessions =
|
|
from(
|
|
s in "sessions",
|
|
where: s.timestamp >= fragment("now() - INTERVAL ? SECOND", ^forget_session_after()),
|
|
group_by: s.session_id,
|
|
select: %{session_id: s.session_id, timestamp: max(s.timestamp)}
|
|
)
|
|
|
|
sessions =
|
|
try do
|
|
Plausible.ClickhouseRepo.all(
|
|
from s in Plausible.ClickhouseSession,
|
|
join: ls in subquery(latest_sessions),
|
|
on: s.session_id == ls.session_id and s.timestamp == ls.timestamp,
|
|
order_by: s.timestamp
|
|
)
|
|
|> Enum.map(fn s -> {s.user_id, s} end)
|
|
|> Enum.into(%{})
|
|
rescue
|
|
_e -> %{}
|
|
end
|
|
|
|
{:ok, %{timer: timer, sessions: sessions, buffer: buffer}}
|
|
end
|
|
|
|
def on_event(event, prev_user_id, pid \\ __MODULE__) do
|
|
GenServer.call(pid, {:on_event, event, prev_user_id})
|
|
end
|
|
|
|
def handle_call(
|
|
{:on_event, event, prev_user_id},
|
|
_from,
|
|
%{sessions: sessions, buffer: buffer} = state
|
|
) do
|
|
found_session = sessions[event.user_id] || (prev_user_id && sessions[prev_user_id])
|
|
active = is_active?(found_session, event)
|
|
|
|
updated_sessions =
|
|
cond do
|
|
found_session && active ->
|
|
new_session = update_session(found_session, event)
|
|
buffer.insert([%{new_session | sign: 1}, %{found_session | sign: -1}])
|
|
Map.put(sessions, event.user_id, new_session)
|
|
|
|
found_session && !active ->
|
|
new_session = new_session_from_event(event)
|
|
buffer.insert([new_session])
|
|
Map.put(sessions, event.user_id, new_session)
|
|
|
|
true ->
|
|
new_session = new_session_from_event(event)
|
|
buffer.insert([new_session])
|
|
Map.put(sessions, event.user_id, new_session)
|
|
end
|
|
|
|
session_id = updated_sessions[event.user_id].session_id
|
|
{:reply, session_id, %{state | sessions: updated_sessions}}
|
|
end
|
|
|
|
defp is_active?(session, event) do
|
|
session && Timex.diff(event.timestamp, session.timestamp, :second) < session_length_seconds()
|
|
end
|
|
|
|
defp update_session(session, event) do
|
|
%{
|
|
session
|
|
| user_id: event.user_id,
|
|
timestamp: event.timestamp,
|
|
exit_page: event.pathname,
|
|
is_bounce: false,
|
|
duration: Timex.diff(event.timestamp, session.start, :second) |> abs,
|
|
pageviews:
|
|
if(event.name == "pageview", do: session.pageviews + 1, else: session.pageviews),
|
|
events: session.events + 1
|
|
}
|
|
end
|
|
|
|
defp new_session_from_event(event) do
|
|
%Plausible.ClickhouseSession{
|
|
sign: 1,
|
|
session_id: Plausible.ClickhouseSession.random_uint64(),
|
|
hostname: event.hostname,
|
|
domain: event.domain,
|
|
user_id: event.user_id,
|
|
entry_page: event.pathname,
|
|
exit_page: event.pathname,
|
|
is_bounce: true,
|
|
duration: 0,
|
|
pageviews: if(event.name == "pageview", do: 1, else: 0),
|
|
events: 1,
|
|
referrer: event.referrer,
|
|
referrer_source: event.referrer_source,
|
|
utm_medium: event.utm_medium,
|
|
utm_source: event.utm_source,
|
|
utm_campaign: event.utm_campaign,
|
|
country_code: event.country_code,
|
|
screen_size: event.screen_size,
|
|
operating_system: event.operating_system,
|
|
operating_system_version: event.operating_system_version,
|
|
browser: event.browser,
|
|
browser_version: event.browser_version,
|
|
timestamp: event.timestamp,
|
|
start: event.timestamp
|
|
}
|
|
end
|
|
|
|
def handle_info(:garbage_collect, state) do
|
|
Logger.debug("Session store collecting garbage")
|
|
|
|
now = Timex.now()
|
|
|
|
new_sessions =
|
|
Enum.reduce(state[:sessions], %{}, fn {key, session}, acc ->
|
|
if Timex.diff(now, session.timestamp, :second) <= forget_session_after() do
|
|
Map.put(acc, key, session)
|
|
else
|
|
# forget the session
|
|
acc
|
|
end
|
|
end)
|
|
|
|
Process.cancel_timer(state[:timer])
|
|
|
|
new_timer =
|
|
Process.send_after(self(), :garbage_collect, @garbage_collect_interval_milliseconds)
|
|
|
|
Logger.debug(fn ->
|
|
n_old = Enum.count(state[:sessions])
|
|
n_new = Enum.count(new_sessions)
|
|
"Removed #{n_old - n_new} sessions from store"
|
|
end)
|
|
|
|
{:noreply, %{state | sessions: new_sessions, timer: new_timer}}
|
|
end
|
|
|
|
defp session_length_seconds(), do: Application.get_env(:plausible, :session_length_minutes) * 60
|
|
defp forget_session_after(), do: session_length_seconds() * 2
|
|
end
|