2019-09-02 14:29:19 +03:00
|
|
|
defmodule PlausibleWeb.Api.ExternalController do
|
|
|
|
use PlausibleWeb, :controller
|
|
|
|
require Logger
|
2020-05-21 13:36:53 +03:00
|
|
|
@hash_key Keyword.fetch!(Application.get_env(:plausible, PlausibleWeb.Endpoint), :secret_key_base) |> binary_part(0, 16)
|
2019-09-02 14:29:19 +03:00
|
|
|
|
2019-10-31 06:49:46 +03:00
|
|
|
def event(conn, _params) do
|
2019-09-02 14:29:19 +03:00
|
|
|
params = parse_body(conn)
|
|
|
|
|
2019-10-31 06:49:46 +03:00
|
|
|
case create_event(conn, params) do
|
2019-12-03 12:42:17 +03:00
|
|
|
{:ok, nil} ->
|
|
|
|
conn |> send_resp(202, "")
|
|
|
|
{:ok, event} ->
|
2020-02-27 12:46:48 +03:00
|
|
|
Plausible.Ingest.FingerprintSession.on_event(event)
|
2019-09-02 14:29:19 +03:00
|
|
|
conn |> send_resp(202, "")
|
|
|
|
{:error, changeset} ->
|
|
|
|
request = Sentry.Plug.build_request_interface_data(conn, [])
|
2019-10-31 06:49:46 +03:00
|
|
|
Sentry.capture_message("Error processing event", extra: %{errors: inspect(changeset.errors), params: params, request: request})
|
2020-02-12 12:11:02 +03:00
|
|
|
Logger.info("Error processing event: #{inspect(changeset)}")
|
2019-09-02 14:29:19 +03:00
|
|
|
conn |> send_resp(400, "")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-12-18 11:05:30 +03:00
|
|
|
def unload(conn, _params) do
|
|
|
|
params = parse_body(conn)
|
2020-02-27 12:46:48 +03:00
|
|
|
fingerprint = calculate_fingerprint(conn, params)
|
2020-02-27 13:04:13 +03:00
|
|
|
Plausible.Ingest.FingerprintSession.on_unload(fingerprint, Timex.now())
|
2019-12-18 11:05:30 +03:00
|
|
|
conn |> send_resp(202, "")
|
|
|
|
end
|
|
|
|
|
2019-09-02 14:29:19 +03:00
|
|
|
def error(conn, _params) do
|
|
|
|
request = Sentry.Plug.build_request_interface_data(conn, [])
|
|
|
|
Sentry.capture_message("JS snippet error", request: request)
|
|
|
|
send_resp(conn, 200, "")
|
|
|
|
end
|
|
|
|
|
2019-10-31 06:49:46 +03:00
|
|
|
defp create_event(conn, params) do
|
2020-03-31 15:01:27 +03:00
|
|
|
uri = params["url"] && URI.parse(params["url"])
|
2020-04-02 13:43:06 +03:00
|
|
|
country_code = Plug.Conn.get_req_header(conn, "x-country") |> List.first
|
2019-09-02 14:29:19 +03:00
|
|
|
user_agent = Plug.Conn.get_req_header(conn, "user-agent") |> List.first
|
2019-10-31 06:49:46 +03:00
|
|
|
if UAInspector.bot?(user_agent) do
|
2019-09-02 14:29:19 +03:00
|
|
|
{:ok, nil}
|
|
|
|
else
|
|
|
|
ua = if user_agent do
|
|
|
|
UAInspector.Parser.parse(user_agent)
|
|
|
|
end
|
|
|
|
|
2020-02-12 12:11:02 +03:00
|
|
|
ref = parse_referrer(uri, params["referrer"])
|
|
|
|
initial_ref = parse_referrer(uri, params["initial_referrer"])
|
2019-09-02 14:29:19 +03:00
|
|
|
|
2019-10-31 06:49:46 +03:00
|
|
|
event_attrs = %{
|
|
|
|
name: params["name"],
|
2020-03-31 15:01:27 +03:00
|
|
|
hostname: strip_www(uri && uri.host),
|
|
|
|
domain: strip_www(params["domain"]) || strip_www(uri && uri.host),
|
2020-05-25 12:25:41 +03:00
|
|
|
pathname: uri && (uri.path || "/"),
|
2019-09-02 14:29:19 +03:00
|
|
|
country_code: country_code,
|
2020-02-10 17:00:19 +03:00
|
|
|
fingerprint: calculate_fingerprint(conn, params),
|
2019-09-02 14:29:19 +03:00
|
|
|
operating_system: ua && os_name(ua),
|
|
|
|
browser: ua && browser_name(ua),
|
2020-02-12 12:11:02 +03:00
|
|
|
referrer_source: params["source"] || referrer_source(ref),
|
|
|
|
referrer: clean_referrer(ref),
|
|
|
|
initial_referrer_source: params["initial_source"] || referrer_source(initial_ref),
|
|
|
|
initial_referrer: clean_referrer(initial_ref),
|
2019-09-02 14:29:19 +03:00
|
|
|
screen_size: calculate_screen_size(params["screen_width"])
|
|
|
|
}
|
|
|
|
|
2020-05-07 14:28:41 +03:00
|
|
|
changeset = Plausible.Event.changeset(%Plausible.Event{}, event_attrs)
|
2020-05-21 13:36:53 +03:00
|
|
|
if changeset.valid? do
|
|
|
|
event = struct(Plausible.ClickhouseEvent, event_attrs)
|
2020-05-07 14:53:06 +03:00
|
|
|
|> Map.put(:timestamp, NaiveDateTime.utc_now())
|
2020-05-21 13:36:53 +03:00
|
|
|
|> Map.put(:user_id, generate_user_id(conn, params))
|
|
|
|
|
|
|
|
session_id = Plausible.Session.Store.on_event(event)
|
|
|
|
|
|
|
|
Map.put(event, :session_id, session_id)
|
2020-05-07 14:53:06 +03:00
|
|
|
|> Plausible.Event.WriteBuffer.insert()
|
|
|
|
end
|
2020-05-07 14:28:41 +03:00
|
|
|
Plausible.Repo.insert(changeset)
|
2019-09-02 14:29:19 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-02-12 12:11:02 +03:00
|
|
|
defp parse_referrer(_, nil), do: nil
|
|
|
|
defp parse_referrer(uri, referrer_str) do
|
|
|
|
referrer_uri = URI.parse(referrer_str)
|
|
|
|
|
|
|
|
if strip_www(referrer_uri.host) !== strip_www(uri.host) && referrer_uri.host !== "localhost" do
|
|
|
|
RefInspector.parse(referrer_str)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-02-10 17:00:19 +03:00
|
|
|
defp calculate_fingerprint(conn, params) do
|
2020-02-11 11:10:53 +03:00
|
|
|
user_agent = List.first(Plug.Conn.get_req_header(conn, "user-agent")) || ""
|
2020-04-02 13:43:06 +03:00
|
|
|
ip_address = List.first(Plug.Conn.get_req_header(conn, "x-bb-ip")) || "" # Netlify sets this header as the remote client IP
|
2020-02-11 11:10:53 +03:00
|
|
|
domain = strip_www(params["domain"]) || ""
|
2020-02-11 12:02:44 +03:00
|
|
|
|
|
|
|
:crypto.hash(:sha256, [user_agent, ip_address, domain])
|
|
|
|
|> Base.encode16
|
|
|
|
|> String.downcase
|
2020-02-11 11:10:53 +03:00
|
|
|
end
|
|
|
|
|
2020-05-21 13:36:53 +03:00
|
|
|
defp generate_user_id(conn, params) do
|
|
|
|
user_agent = List.first(Plug.Conn.get_req_header(conn, "user-agent")) || ""
|
|
|
|
ip_address = List.first(Plug.Conn.get_req_header(conn, "x-bb-ip")) || "" # Netlify sets this header as the remote client IP
|
|
|
|
domain = strip_www(params["domain"]) || ""
|
|
|
|
|
|
|
|
SipHash.hash!(@hash_key, user_agent <> ip_address <> domain)
|
|
|
|
end
|
|
|
|
|
2019-09-04 12:50:56 +03:00
|
|
|
defp calculate_screen_size(nil) , do: nil
|
2019-09-02 14:29:19 +03:00
|
|
|
defp calculate_screen_size(width) when width < 576, do: "Mobile"
|
|
|
|
defp calculate_screen_size(width) when width < 992, do: "Tablet"
|
|
|
|
defp calculate_screen_size(width) when width < 1440, do: "Laptop"
|
|
|
|
defp calculate_screen_size(width) when width >= 1440, do: "Desktop"
|
|
|
|
|
2020-02-12 12:11:02 +03:00
|
|
|
defp clean_referrer(nil), do: nil
|
|
|
|
defp clean_referrer(ref) do
|
2020-03-02 11:47:25 +03:00
|
|
|
uri = URI.parse(ref.referer)
|
2019-09-02 14:29:19 +03:00
|
|
|
|
|
|
|
if uri && uri.scheme in ["http", "https"] do
|
|
|
|
host = String.replace_prefix(uri.host, "www.", "")
|
2020-03-02 11:47:25 +03:00
|
|
|
path = uri.path || ""
|
|
|
|
host <> String.trim_trailing(path, "/")
|
2019-09-02 14:29:19 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
defp parse_body(conn) do
|
|
|
|
{:ok, body, _conn} = Plug.Conn.read_body(conn)
|
|
|
|
Jason.decode!(body)
|
|
|
|
end
|
|
|
|
|
|
|
|
defp strip_www(nil), do: nil
|
|
|
|
defp strip_www(hostname) do
|
|
|
|
String.replace_prefix(hostname, "www.", "")
|
|
|
|
end
|
|
|
|
|
|
|
|
defp browser_name(ua) do
|
|
|
|
case ua.client do
|
|
|
|
%UAInspector.Result.Client{name: "Mobile Safari"} -> "Safari"
|
|
|
|
%UAInspector.Result.Client{name: "Chrome Mobile"} -> "Chrome"
|
|
|
|
%UAInspector.Result.Client{name: "Chrome Mobile iOS"} -> "Chrome"
|
|
|
|
%UAInspector.Result.Client{type: "mobile app"} -> "Mobile App"
|
|
|
|
:unknown -> nil
|
|
|
|
client -> client.name
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
defp os_name(ua) do
|
|
|
|
case ua.os do
|
|
|
|
:unknown -> nil
|
|
|
|
os -> os.name
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-02-12 12:11:02 +03:00
|
|
|
defp referrer_source(nil), do: nil
|
|
|
|
defp referrer_source(ref) do
|
2019-09-02 14:29:19 +03:00
|
|
|
case ref.source do
|
|
|
|
:unknown ->
|
2020-02-12 12:11:02 +03:00
|
|
|
clean_uri(ref.referer)
|
2019-09-02 14:29:19 +03:00
|
|
|
source ->
|
|
|
|
source
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
defp clean_uri(uri) do
|
|
|
|
uri = URI.parse(String.trim(uri))
|
|
|
|
if uri.scheme in ["http", "https"] do
|
|
|
|
String.replace_leading(uri.host, "www.", "")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|