2019-09-02 14:29:19 +03:00
|
|
|
defmodule PlausibleWeb.Api.ExternalController do
|
|
|
|
use PlausibleWeb, :controller
|
|
|
|
require Logger
|
|
|
|
|
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)
|
2020-06-16 16:21:08 +03:00
|
|
|
Sentry.Context.set_extra_context(%{request: params})
|
2019-09-02 14:29:19 +03:00
|
|
|
|
2019-10-31 06:49:46 +03:00
|
|
|
case create_event(conn, params) do
|
2020-06-05 16:14:17 +03:00
|
|
|
{:ok, _} ->
|
2019-09-02 14:29:19 +03:00
|
|
|
conn |> send_resp(202, "")
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2019-09-02 14:29:19 +03:00
|
|
|
{:error, changeset} ->
|
|
|
|
request = Sentry.Plug.build_request_interface_data(conn, [])
|
2020-06-08 10:35:13 +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
|
|
|
|
|
|
|
|
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-06-08 10:35:13 +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
|
2020-06-08 10:35:13 +03:00
|
|
|
ua =
|
|
|
|
if user_agent do
|
|
|
|
UAInspector.Parser.parse(user_agent)
|
|
|
|
end
|
2019-09-02 14:29:19 +03:00
|
|
|
|
2020-02-12 12:11:02 +03:00
|
|
|
ref = parse_referrer(uri, params["referrer"])
|
2020-06-12 09:51:45 +03:00
|
|
|
country_code = visitor_country(conn)
|
2019-09-02 14:29:19 +03:00
|
|
|
|
2019-10-31 06:49:46 +03:00
|
|
|
event_attrs = %{
|
2020-06-05 16:14:17 +03:00
|
|
|
timestamp: NaiveDateTime.utc_now(),
|
2019-10-31 06:49:46 +03:00
|
|
|
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 || "/"),
|
2020-06-05 16:14:17 +03:00
|
|
|
user_id: generate_user_id(conn, params),
|
2019-09-02 14:29:19 +03:00
|
|
|
country_code: country_code,
|
|
|
|
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),
|
2019-09-02 14:29:19 +03:00
|
|
|
screen_size: calculate_screen_size(params["screen_width"])
|
|
|
|
}
|
|
|
|
|
2020-06-05 16:14:17 +03:00
|
|
|
changeset = Plausible.ClickhouseEvent.changeset(%Plausible.ClickhouseEvent{}, event_attrs)
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2020-05-21 13:36:53 +03:00
|
|
|
if changeset.valid? do
|
|
|
|
event = struct(Plausible.ClickhouseEvent, event_attrs)
|
|
|
|
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()
|
2020-06-05 16:14:17 +03:00
|
|
|
else
|
|
|
|
{:error, changeset}
|
2020-05-07 14:53:06 +03:00
|
|
|
end
|
2019-09-02 14:29:19 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-06-12 09:51:45 +03:00
|
|
|
defp get_ip(conn) do
|
|
|
|
forwarded_for = List.first(Plug.Conn.get_req_header(conn, "x-forwarded-for"))
|
|
|
|
|
|
|
|
if forwarded_for do
|
|
|
|
String.split(forwarded_for, ",")
|
|
|
|
|> Enum.map(&String.trim/1)
|
|
|
|
|> List.first
|
|
|
|
else
|
|
|
|
to_string(:inet_parse.ntoa(conn.remote_ip))
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
defp visitor_country(conn) do
|
|
|
|
result = get_ip(conn)
|
|
|
|
|> Geolix.lookup()
|
2020-06-12 11:15:19 +03:00
|
|
|
|> Map.get(:country)
|
2020-06-12 09:51:45 +03:00
|
|
|
|
2020-06-12 18:42:38 +03:00
|
|
|
if result && result.country do
|
2020-06-12 09:51:45 +03:00
|
|
|
result.country.iso_code
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-02-12 12:11:02 +03:00
|
|
|
defp parse_referrer(_, nil), do: nil
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2020-02-12 12:11:02 +03:00
|
|
|
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-05-21 13:36:53 +03:00
|
|
|
defp generate_user_id(conn, params) do
|
2020-06-08 10:35:13 +03:00
|
|
|
hash_key =
|
|
|
|
Keyword.fetch!(Application.get_env(:plausible, PlausibleWeb.Endpoint), :secret_key_base)
|
|
|
|
|> binary_part(0, 16)
|
|
|
|
|
2020-05-21 13:36:53 +03:00
|
|
|
user_agent = List.first(Plug.Conn.get_req_header(conn, "user-agent")) || ""
|
2020-06-12 09:51:45 +03:00
|
|
|
ip_address = get_ip(conn)
|
2020-05-21 13:36:53 +03:00
|
|
|
domain = strip_www(params["domain"]) || ""
|
|
|
|
|
2020-06-05 11:15:26 +03:00
|
|
|
SipHash.hash!(hash_key, user_agent <> ip_address <> domain)
|
2020-05-21 13:36:53 +03:00
|
|
|
end
|
|
|
|
|
2020-06-08 10:35:13 +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
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2020-02-12 12:11:02 +03:00
|
|
|
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
|
|
|
|
2020-06-25 17:54:11 +03:00
|
|
|
if uri && uri.host && uri.scheme in ["http", "https"] do
|
2019-09-02 14:29:19 +03:00
|
|
|
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
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2019-09-02 14:29:19 +03:00
|
|
|
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
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2020-02-12 12:11:02 +03:00
|
|
|
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)
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2019-09-02 14:29:19 +03:00
|
|
|
source ->
|
|
|
|
source
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
defp clean_uri(uri) do
|
|
|
|
uri = URI.parse(String.trim(uri))
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2020-06-25 17:54:11 +03:00
|
|
|
if uri && uri.host && uri.scheme in ["http", "https"] do
|
2019-09-02 14:29:19 +03:00
|
|
|
String.replace_leading(uri.host, "www.", "")
|
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|