2019-09-02 14:29:19 +03:00
|
|
|
defmodule PlausibleWeb.Api.ExternalController do
|
|
|
|
use PlausibleWeb, :controller
|
2021-11-05 15:58:57 +03:00
|
|
|
use OpenTelemetryDecorator
|
2019-09-02 14:29:19 +03:00
|
|
|
require Logger
|
|
|
|
|
2019-10-31 06:49:46 +03:00
|
|
|
def event(conn, _params) do
|
2021-11-18 11:36:16 +03:00
|
|
|
with {:ok, params} <- parse_body(conn),
|
|
|
|
_ <- Sentry.Context.set_extra_context(%{request: params}),
|
|
|
|
:ok <- create_event(conn, params) do
|
|
|
|
conn |> put_status(202) |> text("ok")
|
|
|
|
else
|
|
|
|
{:error, :invalid_json} ->
|
|
|
|
conn
|
|
|
|
|> put_status(400)
|
|
|
|
|> json(%{errors: %{request: "Unable to parse request body as json"}})
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2021-09-24 10:38:23 +03:00
|
|
|
{:error, errors} ->
|
|
|
|
conn |> put_status(400) |> json(%{errors: errors})
|
2019-09-02 14:29:19 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
def error(conn, _params) do
|
2021-03-31 11:38:14 +03:00
|
|
|
Sentry.capture_message("JS snippet error")
|
2019-09-02 14:29:19 +03:00
|
|
|
send_resp(conn, 200, "")
|
|
|
|
end
|
|
|
|
|
2020-07-20 10:34:35 +03:00
|
|
|
def health(conn, _params) do
|
2020-07-21 09:58:00 +03:00
|
|
|
postgres_health =
|
|
|
|
case Ecto.Adapters.SQL.query(Plausible.Repo, "SELECT 1", []) do
|
|
|
|
{:ok, _} -> "ok"
|
|
|
|
e -> "error: #{inspect(e)}"
|
|
|
|
end
|
2020-07-20 10:34:35 +03:00
|
|
|
|
2020-07-21 09:58:00 +03:00
|
|
|
clickhouse_health =
|
2020-09-17 16:36:01 +03:00
|
|
|
case Ecto.Adapters.SQL.query(Plausible.ClickhouseRepo, "SELECT 1", []) do
|
2020-07-21 09:58:00 +03:00
|
|
|
{:ok, _} -> "ok"
|
|
|
|
e -> "error: #{inspect(e)}"
|
|
|
|
end
|
2020-07-20 10:34:35 +03:00
|
|
|
|
2020-07-21 09:58:00 +03:00
|
|
|
status =
|
|
|
|
case {postgres_health, clickhouse_health} do
|
|
|
|
{"ok", "ok"} -> 200
|
|
|
|
_ -> 500
|
|
|
|
end
|
2020-07-20 10:34:35 +03:00
|
|
|
|
|
|
|
put_status(conn, status)
|
|
|
|
|> json(%{
|
|
|
|
postgres: postgres_health,
|
2020-07-21 09:58:00 +03:00
|
|
|
clickhouse: clickhouse_health
|
2020-07-20 10:34:35 +03:00
|
|
|
})
|
|
|
|
end
|
|
|
|
|
2021-11-05 15:58:57 +03:00
|
|
|
@decorate trace("ingest.parse_user_agent")
|
2020-12-14 17:06:43 +03:00
|
|
|
defp parse_user_agent(conn) do
|
|
|
|
user_agent = Plug.Conn.get_req_header(conn, "user-agent") |> List.first()
|
2021-01-04 17:38:56 +03:00
|
|
|
|
|
|
|
if user_agent do
|
2021-10-18 12:27:21 +03:00
|
|
|
res =
|
|
|
|
Cachex.fetch(:user_agents, user_agent, fn ua ->
|
|
|
|
UAInspector.parse(ua)
|
|
|
|
end)
|
|
|
|
|
|
|
|
case res do
|
|
|
|
{:ok, user_agent} -> user_agent
|
|
|
|
{:commit, user_agent} -> user_agent
|
|
|
|
_ -> nil
|
|
|
|
end
|
2021-01-04 17:38:56 +03:00
|
|
|
end
|
2020-12-14 17:06:43 +03:00
|
|
|
end
|
|
|
|
|
2021-09-24 14:28:10 +03:00
|
|
|
@no_domain_error {:error, %{domain: ["can't be blank"]}}
|
|
|
|
|
2019-10-31 06:49:46 +03:00
|
|
|
defp create_event(conn, params) do
|
2020-08-24 15:16:07 +03:00
|
|
|
params = %{
|
|
|
|
"name" => params["n"] || params["name"],
|
|
|
|
"url" => params["u"] || params["url"],
|
|
|
|
"referrer" => params["r"] || params["referrer"],
|
|
|
|
"domain" => params["d"] || params["domain"],
|
|
|
|
"screen_width" => params["w"] || params["screen_width"],
|
2020-08-25 10:56:36 +03:00
|
|
|
"hash_mode" => params["h"] || params["hashMode"],
|
2020-10-28 12:09:04 +03:00
|
|
|
"meta" => parse_meta(params)
|
2020-08-24 15:16:07 +03:00
|
|
|
}
|
|
|
|
|
2020-12-14 17:06:43 +03:00
|
|
|
ua = parse_user_agent(conn)
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2021-09-28 22:26:36 +03:00
|
|
|
if is_bot?(ua) || params["domain"] in Application.get_env(:plausible, :domain_blacklist) do
|
2021-04-27 10:26:44 +03:00
|
|
|
:ok
|
2019-09-02 14:29:19 +03:00
|
|
|
else
|
2020-11-17 15:40:10 +03:00
|
|
|
uri = params["url"] && URI.parse(params["url"])
|
2021-09-16 11:05:43 +03:00
|
|
|
host = if uri && uri.host == "", do: "(none)", else: uri && uri.host
|
2021-10-25 11:02:38 +03:00
|
|
|
query = decode_query_params(uri)
|
2020-11-03 12:20:11 +03:00
|
|
|
|
2020-02-12 12:11:02 +03:00
|
|
|
ref = parse_referrer(uri, params["referrer"])
|
2021-11-23 12:39:09 +03:00
|
|
|
location_details = visitor_location_details(conn)
|
2020-07-15 11:47:24 +03:00
|
|
|
salts = Plausible.Session.Salts.fetch()
|
2019-09-02 14:29:19 +03:00
|
|
|
|
2019-10-31 06:49:46 +03:00
|
|
|
event_attrs = %{
|
2020-09-17 16:36:01 +03:00
|
|
|
timestamp: NaiveDateTime.utc_now() |> NaiveDateTime.truncate(:second),
|
2019-10-31 06:49:46 +03:00
|
|
|
name: params["name"],
|
2021-09-16 11:05:43 +03:00
|
|
|
hostname: strip_www(host),
|
2020-08-25 10:56:36 +03:00
|
|
|
pathname: get_pathname(uri, params["hash_mode"]),
|
2021-04-27 11:38:56 +03:00
|
|
|
referrer_source: get_referrer_source(query, ref),
|
|
|
|
referrer: clean_referrer(ref),
|
|
|
|
utm_medium: query["utm_medium"],
|
|
|
|
utm_source: query["utm_source"],
|
|
|
|
utm_campaign: query["utm_campaign"],
|
2021-12-16 12:02:09 +03:00
|
|
|
utm_content: query["utm_content"],
|
|
|
|
utm_term: query["utm_term"],
|
2021-11-23 12:39:09 +03:00
|
|
|
country_code: location_details[:country_code],
|
|
|
|
country_geoname_id: location_details[:country_geoname_id],
|
|
|
|
subdivision1_code: location_details[:subdivision1_code],
|
|
|
|
subdivision2_code: location_details[:subdivision2_code],
|
|
|
|
city_geoname_id: location_details[:city_geoname_id],
|
2021-04-27 11:38:56 +03:00
|
|
|
operating_system: ua && os_name(ua),
|
|
|
|
operating_system_version: ua && os_version(ua),
|
|
|
|
browser: ua && browser_name(ua),
|
|
|
|
browser_version: ua && browser_version(ua),
|
|
|
|
screen_size: calculate_screen_size(params["screen_width"]),
|
2020-10-28 12:09:04 +03:00
|
|
|
"meta.key": Map.keys(params["meta"]),
|
2020-11-18 15:53:43 +03:00
|
|
|
"meta.value": Map.values(params["meta"]) |> Enum.map(&Kernel.to_string/1)
|
2019-09-02 14:29:19 +03:00
|
|
|
}
|
|
|
|
|
2021-09-24 14:28:10 +03:00
|
|
|
Enum.reduce_while(get_domains(params, uri), @no_domain_error, fn domain, _res ->
|
2021-04-27 11:10:37 +03:00
|
|
|
user_id = generate_user_id(conn, domain, event_attrs[:hostname], salts[:current])
|
|
|
|
|
|
|
|
previous_user_id =
|
|
|
|
salts[:previous] &&
|
|
|
|
generate_user_id(conn, domain, event_attrs[:hostname], salts[:previous])
|
|
|
|
|
|
|
|
changeset =
|
|
|
|
event_attrs
|
|
|
|
|> Map.merge(%{domain: domain, user_id: user_id})
|
|
|
|
|> Plausible.ClickhouseEvent.new()
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2021-04-27 10:26:44 +03:00
|
|
|
if changeset.valid? do
|
2021-04-27 11:38:56 +03:00
|
|
|
event = Ecto.Changeset.apply_changes(changeset)
|
2021-04-27 10:26:44 +03:00
|
|
|
session_id = Plausible.Session.Store.on_event(event, previous_user_id)
|
2020-05-21 13:36:53 +03:00
|
|
|
|
2021-04-27 10:26:44 +03:00
|
|
|
event
|
|
|
|
|> Map.put(:session_id, session_id)
|
|
|
|
|> Plausible.Event.WriteBuffer.insert()
|
|
|
|
|
|
|
|
{:cont, :ok}
|
|
|
|
else
|
2021-09-24 10:38:23 +03:00
|
|
|
errors = Ecto.Changeset.traverse_errors(changeset, &encode_error/1)
|
|
|
|
{:halt, {:error, errors}}
|
2021-04-27 10:26:44 +03:00
|
|
|
end
|
|
|
|
end)
|
2019-09-02 14:29:19 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-09-24 10:38:23 +03:00
|
|
|
# https://hexdocs.pm/ecto/Ecto.Changeset.html#traverse_errors/2-examples
|
|
|
|
defp encode_error({msg, opts}) do
|
|
|
|
Regex.replace(~r"%{(\w+)}", msg, fn _, key ->
|
|
|
|
opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string()
|
|
|
|
end)
|
|
|
|
end
|
|
|
|
|
2020-11-10 16:18:59 +03:00
|
|
|
defp is_bot?(%UAInspector.Result.Bot{}), do: true
|
2020-12-29 16:17:27 +03:00
|
|
|
|
|
|
|
defp is_bot?(%UAInspector.Result{client: %UAInspector.Result.Client{name: "Headless Chrome"}}),
|
|
|
|
do: true
|
|
|
|
|
2020-11-10 16:18:59 +03:00
|
|
|
defp is_bot?(_), do: false
|
|
|
|
|
2020-10-28 12:09:04 +03:00
|
|
|
defp parse_meta(params) do
|
2020-10-30 11:49:41 +03:00
|
|
|
raw_meta = params["m"] || params["meta"] || params["p"] || params["props"]
|
2020-11-03 12:20:11 +03:00
|
|
|
|
2021-11-10 16:51:43 +03:00
|
|
|
with {:ok, parsed_json} <- decode_raw_props(raw_meta),
|
2021-10-22 16:48:59 +03:00
|
|
|
:ok <- validate_custom_props(parsed_json) do
|
|
|
|
parsed_json
|
2020-10-28 12:09:04 +03:00
|
|
|
else
|
2021-10-22 16:48:59 +03:00
|
|
|
_ -> %{}
|
2020-10-28 12:09:04 +03:00
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-10-22 16:48:59 +03:00
|
|
|
defp validate_custom_props(props) do
|
|
|
|
is_valid =
|
|
|
|
Enum.all?(props, fn {_key, val} ->
|
2021-11-18 11:28:20 +03:00
|
|
|
!is_list(val) && !is_map(val)
|
2021-10-22 16:48:59 +03:00
|
|
|
end)
|
|
|
|
|
|
|
|
if is_valid, do: :ok, else: :invalid_props
|
|
|
|
end
|
|
|
|
|
2021-11-10 16:51:43 +03:00
|
|
|
defp decode_raw_props(props) when is_map(props), do: {:ok, props}
|
|
|
|
|
|
|
|
defp decode_raw_props(raw_json) when is_binary(raw_json) do
|
|
|
|
case Jason.decode(raw_json) do
|
|
|
|
{:ok, parsed_props} when is_map(parsed_props) ->
|
|
|
|
{:ok, parsed_props}
|
|
|
|
|
|
|
|
_ ->
|
|
|
|
:not_a_map
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
|
|
|
defp decode_raw_props(_), do: :bad_format
|
|
|
|
|
2021-04-27 10:26:44 +03:00
|
|
|
defp get_domains(params, uri) do
|
|
|
|
if params["domain"] do
|
|
|
|
String.split(params["domain"], ",")
|
|
|
|
|> Enum.map(&String.trim/1)
|
|
|
|
|> Enum.map(&strip_www/1)
|
|
|
|
else
|
|
|
|
List.wrap(strip_www(uri && uri.host))
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-08-25 10:56:36 +03:00
|
|
|
defp get_pathname(nil, _), do: "/"
|
2020-11-03 12:20:11 +03:00
|
|
|
|
2020-08-25 10:56:36 +03:00
|
|
|
defp get_pathname(uri, hash_mode) do
|
2020-12-29 16:17:27 +03:00
|
|
|
pathname =
|
|
|
|
(uri.path || "/")
|
|
|
|
|> URI.decode()
|
2020-11-03 12:20:11 +03:00
|
|
|
|
2020-08-25 10:56:36 +03:00
|
|
|
if hash_mode && uri.fragment do
|
2020-11-17 15:40:10 +03:00
|
|
|
pathname <> "#" <> URI.decode(uri.fragment)
|
2020-08-25 10:56:36 +03:00
|
|
|
else
|
|
|
|
pathname
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2021-12-29 16:29:13 +03:00
|
|
|
@city_overrides %{
|
|
|
|
# UK
|
|
|
|
# Shadwell -> London
|
|
|
|
6_690_595 => 2_643_743,
|
|
|
|
# City of London -> London
|
|
|
|
2_643_741 => 2_643_743,
|
|
|
|
# South Bank -> London
|
|
|
|
6_545_251 => 2_643_743,
|
|
|
|
# Soho -> London
|
|
|
|
6_545_173 => 2_643_743,
|
|
|
|
# Whitechapel -> London
|
|
|
|
2_634_112 => 2_643_743,
|
|
|
|
# King's Cross -> London
|
|
|
|
6_690_589 => 2_643_743,
|
|
|
|
# Poplar -> London
|
|
|
|
2_640_091 => 2_643_743,
|
|
|
|
# Hackney -> London
|
|
|
|
2_647_694 => 2_643_743,
|
|
|
|
|
|
|
|
# India
|
|
|
|
# Navi Mumbai -> Mumbai
|
|
|
|
6_619_347 => 1_275_339,
|
|
|
|
|
|
|
|
# Germany
|
|
|
|
# Bezirk Tempelhof-Schöneberg -> Berlin
|
|
|
|
3_336_297 => 2_950_159,
|
|
|
|
# Bezirk Mitte -> Berlin
|
|
|
|
2_870_912 => 2_950_159,
|
|
|
|
# Bezirk Charlottenburg-Wilmersdorf -> Berlin
|
|
|
|
3_336_294 => 2_950_159,
|
|
|
|
# Bezirk Friedrichshain-Kreuzberg -> Berlin
|
|
|
|
3_336_295 => 2_950_159,
|
|
|
|
# Moosach -> Munich
|
|
|
|
8_351_447 => 2_867_714,
|
|
|
|
# Schwabing-Freimann -> Munich
|
|
|
|
8_351_448 => 2_867_714,
|
|
|
|
# Stadtbezirk 06 -> Düsseldorf
|
|
|
|
6_947_276 => 2_934_246,
|
|
|
|
# Stadtbezirk 04 -> Düsseldorf
|
|
|
|
6_947_274 => 2_934_246,
|
|
|
|
# Köln-Ehrenfeld -> Köln
|
|
|
|
6_947_479 => 2_886_242,
|
|
|
|
# Köln-Lindenthal- -> Köln
|
|
|
|
6_947_481 => 2_886_242,
|
|
|
|
# Beuel -> Bonn
|
|
|
|
2_949_619 => 2_946_447,
|
|
|
|
|
|
|
|
# Austria
|
|
|
|
# Gemeindebezirk Floridsdorf -> Vienna
|
|
|
|
2_779_467 => 2_761_369,
|
|
|
|
# Gemeindebezirk Leopoldstadt -> Vienna
|
|
|
|
2_772_614 => 2_761_369,
|
|
|
|
# Gemeindebezirk Landstrasse -> Vienna
|
|
|
|
2_773_040 => 2_761_369,
|
|
|
|
# Urfahr -> Linz
|
|
|
|
2_762_518 => 2_772_400,
|
|
|
|
|
|
|
|
# Netherlands
|
|
|
|
# Schiphol-Rijk -> Amsterdam
|
|
|
|
10_173_838 => 2_759_794,
|
|
|
|
|
|
|
|
# Czech republic
|
|
|
|
# Praha 5 -> Prague
|
|
|
|
11_951_220 => 3_067_696,
|
|
|
|
# Praha 4 -> Prague
|
|
|
|
11_951_218 => 3_067_696,
|
|
|
|
# Praha 11 -> Prague
|
|
|
|
11_951_232 => 3_067_696,
|
|
|
|
# Praha 10 -> Prague
|
|
|
|
11_951_210 => 3_067_696,
|
|
|
|
# Praha 4 -> Prague
|
|
|
|
8_378_772 => 3_067_696,
|
|
|
|
|
|
|
|
# Estonia
|
|
|
|
# Kristiine linnaosa -> Tallinn
|
|
|
|
11_050_530 => 588_409,
|
|
|
|
# Kesklinna linnaosa -> Tallinn
|
|
|
|
11_053_706 => 588_409,
|
|
|
|
# Lasnamäe linnaosa -> Tallinn
|
|
|
|
11_050_526 => 588_409,
|
|
|
|
# Põhja-Tallinna linnaosa -> Tallinn
|
|
|
|
11_049_594 => 588_409,
|
|
|
|
# Mustamäe linnaosa -> Tallinn
|
|
|
|
11_050_531 => 588_409,
|
|
|
|
# Haabersti linnaosa -> Tallinn
|
|
|
|
11_053_707 => 588_409,
|
|
|
|
# Viimsi -> Tallinn
|
2021-12-29 17:00:17 +03:00
|
|
|
587_629 => 588_409,
|
|
|
|
|
|
|
|
# Sweden
|
|
|
|
# Södermalm => Stockholm
|
|
|
|
2_676_209 => 2_673_730
|
2021-12-29 16:29:13 +03:00
|
|
|
}
|
|
|
|
|
2021-11-05 15:58:57 +03:00
|
|
|
@decorate trace("ingest.geolocation")
|
2021-11-23 12:39:09 +03:00
|
|
|
defp visitor_location_details(conn) do
|
2020-07-02 11:21:11 +03:00
|
|
|
result =
|
2020-08-11 11:04:26 +03:00
|
|
|
PlausibleWeb.RemoteIp.get(conn)
|
2020-07-02 11:21:11 +03:00
|
|
|
|> Geolix.lookup()
|
2020-06-12 09:51:45 +03:00
|
|
|
|
2021-11-23 12:39:09 +03:00
|
|
|
country_code = get_in(result, [:geolocation, :country, :iso_code])
|
|
|
|
city_geoname_id = get_in(result, [:geolocation, :city, :geoname_id])
|
|
|
|
|
|
|
|
subdivision1_code =
|
|
|
|
case result do
|
|
|
|
%{geolocation: %{subdivisions: [%{iso_code: iso_code} | _rest]}} ->
|
|
|
|
country_code <> "-" <> iso_code
|
|
|
|
|
|
|
|
_ ->
|
|
|
|
""
|
|
|
|
end
|
|
|
|
|
|
|
|
subdivision2_code =
|
|
|
|
case result do
|
|
|
|
%{geolocation: %{subdivisions: [_first, %{iso_code: iso_code} | _rest]}} ->
|
|
|
|
country_code <> "-" <> iso_code
|
|
|
|
|
|
|
|
_ ->
|
|
|
|
""
|
|
|
|
end
|
|
|
|
|
|
|
|
%{
|
|
|
|
country_code: country_code,
|
|
|
|
subdivision1_code: subdivision1_code,
|
|
|
|
subdivision2_code: subdivision2_code,
|
2021-12-29 16:29:13 +03:00
|
|
|
city_geoname_id: Map.get(@city_overrides, city_geoname_id, city_geoname_id)
|
2021-11-23 12:39:09 +03:00
|
|
|
}
|
2020-06-12 09:51:45 +03:00
|
|
|
end
|
|
|
|
|
2021-11-05 15:58:57 +03:00
|
|
|
@decorate trace("ingest.parse_referrer")
|
2020-12-14 17:06:43 +03:00
|
|
|
defp parse_referrer(_, nil), do: nil
|
2020-12-29 16:17:27 +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
|
|
|
|
|
2021-04-27 11:10:37 +03:00
|
|
|
defp generate_user_id(conn, domain, hostname, salt) do
|
2020-05-21 13:36:53 +03:00
|
|
|
user_agent = List.first(Plug.Conn.get_req_header(conn, "user-agent")) || ""
|
2020-08-11 11:04:26 +03:00
|
|
|
ip_address = PlausibleWeb.RemoteIp.get(conn)
|
2021-09-10 12:35:00 +03:00
|
|
|
root_domain = get_root_domain(hostname)
|
2020-05-21 13:36:53 +03:00
|
|
|
|
2021-09-10 12:35:00 +03:00
|
|
|
if domain && root_domain do
|
|
|
|
SipHash.hash!(salt, user_agent <> ip_address <> domain <> root_domain)
|
2021-05-03 17:06:36 +03:00
|
|
|
end
|
2020-05-21 13:36:53 +03:00
|
|
|
end
|
|
|
|
|
2021-09-22 12:20:11 +03:00
|
|
|
defp get_root_domain(nil), do: "(none)"
|
2021-09-16 11:22:54 +03:00
|
|
|
|
2021-09-22 12:20:11 +03:00
|
|
|
defp get_root_domain(hostname) do
|
|
|
|
case PublicSuffix.registrable_domain(hostname) do
|
|
|
|
domain when is_binary(domain) -> domain
|
|
|
|
_ -> hostname
|
|
|
|
end
|
2021-09-10 12:35:00 +03:00
|
|
|
end
|
2021-09-10 12:38:03 +03:00
|
|
|
|
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
|
|
|
|
2021-01-07 16:16:04 +03:00
|
|
|
if right_uri?(uri) 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
|
2021-06-02 15:10:44 +03:00
|
|
|
case conn.body_params do
|
|
|
|
%Plug.Conn.Unfetched{} ->
|
|
|
|
{:ok, body, _conn} = Plug.Conn.read_body(conn)
|
2021-11-18 11:36:16 +03:00
|
|
|
|
|
|
|
case Jason.decode(body) do
|
|
|
|
{:ok, params} -> {:ok, params}
|
|
|
|
_ -> {:error, :invalid_json}
|
|
|
|
end
|
2021-06-02 15:10:44 +03:00
|
|
|
|
|
|
|
params ->
|
2021-11-18 11:36:16 +03:00
|
|
|
{:ok, params}
|
2021-06-02 15:10:44 +03:00
|
|
|
end
|
2019-09-02 14:29:19 +03:00
|
|
|
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
|
2020-11-10 16:18:59 +03:00
|
|
|
:unknown -> ""
|
2019-09-02 14:29:19 +03:00
|
|
|
%UAInspector.Result.Client{name: "Mobile Safari"} -> "Safari"
|
|
|
|
%UAInspector.Result.Client{name: "Chrome Mobile"} -> "Chrome"
|
|
|
|
%UAInspector.Result.Client{name: "Chrome Mobile iOS"} -> "Chrome"
|
2020-11-10 16:18:59 +03:00
|
|
|
%UAInspector.Result.Client{name: "Firefox Mobile"} -> "Firefox"
|
|
|
|
%UAInspector.Result.Client{name: "Firefox Mobile iOS"} -> "Firefox"
|
2020-11-23 12:09:21 +03:00
|
|
|
%UAInspector.Result.Client{name: "Opera Mobile"} -> "Opera"
|
2021-12-09 12:49:00 +03:00
|
|
|
%UAInspector.Result.Client{name: "Opera Mini"} -> "Opera"
|
|
|
|
%UAInspector.Result.Client{name: "Opera Mini iOS"} -> "Opera"
|
|
|
|
%UAInspector.Result.Client{name: "Yandex Browser Lite"} -> "Yandex Browser"
|
2020-11-10 16:18:59 +03:00
|
|
|
%UAInspector.Result.Client{name: "Chrome Webview"} -> "Mobile App"
|
2019-09-02 14:29:19 +03:00
|
|
|
%UAInspector.Result.Client{type: "mobile app"} -> "Mobile App"
|
|
|
|
client -> client.name
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-11-10 16:18:59 +03:00
|
|
|
defp major_minor(:unknown), do: ""
|
2020-12-29 16:17:27 +03:00
|
|
|
|
2020-11-10 16:18:59 +03:00
|
|
|
defp major_minor(version) do
|
|
|
|
version
|
|
|
|
|> String.split(".")
|
|
|
|
|> Enum.take(2)
|
|
|
|
|> Enum.join(".")
|
|
|
|
end
|
|
|
|
|
|
|
|
defp browser_version(ua) do
|
|
|
|
case ua.client do
|
|
|
|
:unknown -> ""
|
|
|
|
%UAInspector.Result.Client{type: "mobile app"} -> ""
|
|
|
|
client -> major_minor(client.version)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2019-09-02 14:29:19 +03:00
|
|
|
defp os_name(ua) do
|
|
|
|
case ua.os do
|
2020-11-10 16:18:59 +03:00
|
|
|
:unknown -> ""
|
2019-09-02 14:29:19 +03:00
|
|
|
os -> os.name
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-11-10 16:18:59 +03:00
|
|
|
defp os_version(ua) do
|
|
|
|
case ua.os do
|
|
|
|
:unknown -> ""
|
|
|
|
os -> major_minor(os.version)
|
|
|
|
end
|
|
|
|
end
|
|
|
|
|
2020-09-18 11:37:32 +03:00
|
|
|
defp get_referrer_source(query, ref) do
|
2020-08-24 16:32:24 +03:00
|
|
|
source = query["utm_source"] || query["source"] || query["ref"]
|
|
|
|
source || get_source_from_referrer(ref)
|
|
|
|
end
|
|
|
|
|
|
|
|
defp get_source_from_referrer(nil), do: nil
|
2020-06-08 10:35:13 +03:00
|
|
|
|
2020-08-24 16:32:24 +03:00
|
|
|
defp get_source_from_referrer(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
|
|
|
|
2021-01-07 16:16:04 +03:00
|
|
|
if right_uri?(uri) do
|
2019-09-02 14:29:19 +03:00
|
|
|
String.replace_leading(uri.host, "www.", "")
|
|
|
|
end
|
|
|
|
end
|
2021-01-07 16:16:04 +03:00
|
|
|
|
|
|
|
defp right_uri?(%URI{host: nil}), do: false
|
|
|
|
|
|
|
|
defp right_uri?(%URI{host: host, scheme: scheme})
|
|
|
|
when scheme in ["http", "https"] and byte_size(host) > 0,
|
|
|
|
do: true
|
|
|
|
|
|
|
|
defp right_uri?(_), do: false
|
2021-10-25 11:02:38 +03:00
|
|
|
|
|
|
|
defp decode_query_params(nil), do: nil
|
|
|
|
defp decode_query_params(%URI{query: nil}), do: nil
|
|
|
|
|
|
|
|
defp decode_query_params(%URI{query: query_part}) do
|
|
|
|
try do
|
|
|
|
URI.decode_query(query_part)
|
|
|
|
rescue
|
|
|
|
_ -> nil
|
|
|
|
end
|
|
|
|
end
|
2019-09-02 14:29:19 +03:00
|
|
|
end
|