Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.
TypeScript analyticsanalytics-dashboardclickhouseelixirgoogle-analyticsmarketingopen-source-analyticsphoenixplausible-analyticspostgresqlprivacyprivacy-friendlyself-hostedsimple-analyticsstatisticstailwindcssweb-analyticswebsite-analyticswebsite-statswebsite-tracking
Implement backend core for funnels (#3023)
hq1a356009af8cb
diff --git a/lib/plausible/funnel.ex b/lib/plausible/funnel.exnew file mode 100644index 0000000000..4d8e24c8b2--- /dev/null+++ b/lib/plausible/funnel.ex@@ -0,0 +1,76 @@+defmodule Plausible.Funnel do+ @min_steps 2+ @max_steps 5++ @moduledoc """+ A funnel is a marketing term used to capture and describe the journey+ that users go through, from initial step to conversion.+ A funnel consists of several steps (here: #{@min_steps}..#{@max_steps}).++ This module defines the database schema for storing funnels+ and changeset helpers for enumerating the steps within.++ Each step references a goal (either a Custom Event or Visit)+ - see: `Plausible.Goal`.+ """++ use Ecto.Schema+ import Ecto.Changeset++ alias Plausible.Funnel.Step++ defmacro min_steps() do+ quote do+ unquote(@min_steps)+ end+ end++ defmacro max_steps() do+ quote do+ unquote(@max_steps)+ end+ end++ defmacro __using__(_opts \\ []) do+ quote do+ require Plausible.Funnel+ alias Plausible.Funnel+ end+ end++ @type t() :: %__MODULE__{}+ schema "funnels" do+ field :name, :string+ belongs_to :site, Plausible.Site++ has_many :steps, Step,+ preload_order: [+ asc: :step_order+ ]++ has_many :goals, through: [:steps, :goal]+ timestamps()+ end++ def changeset(funnel \\ %__MODULE__{}, attrs \\ %{}) do+ funnel+ |> cast(attrs, [:name])+ |> validate_required([:name])+ |> cast_assoc(:steps, with: &Step.changeset/2, required: true)+ |> validate_length(:steps, min: @min_steps, max: @max_steps)+ |> put_step_orders()+ |> unique_constraint(:name,+ name: :funnels_name_site_id_index+ )+ end++ def put_step_orders(changeset) do+ if steps = Ecto.Changeset.get_change(changeset, :steps) do+ steps+ |> Enum.with_index(fn step, step_order ->+ Ecto.Changeset.put_change(step, :step_order, step_order + 1)+ end)+ |> then(&Ecto.Changeset.put_change(changeset, :steps, &1))+ end+ end+enddiff --git a/lib/plausible/funnel/step.ex b/lib/plausible/funnel/step.exnew file mode 100644index 0000000000..b57d22c409--- /dev/null+++ b/lib/plausible/funnel/step.ex@@ -0,0 +1,27 @@+defmodule Plausible.Funnel.Step do+ @moduledoc """+ This module defines the database schema for a single Funnel step.+ See: `Plausible.Funnel` for more information.+ """++ use Ecto.Schema+ import Ecto.Changeset++ @type t() :: %__MODULE__{}+ schema "funnel_steps" do+ field :step_order, :integer+ belongs_to :funnel, Plausible.Funnel+ belongs_to :goal, Plausible.Goal+ timestamps()+ end++ def changeset(step, attrs \\ %{}) do+ step+ |> cast(attrs, [:goal_id])+ |> cast_assoc(:goal)+ |> validate_required([:goal_id])+ |> unique_constraint(:goal,+ name: :funnel_steps_goal_id_funnel_id_index+ )+ end+enddiff --git a/lib/plausible/funnels.ex b/lib/plausible/funnels.exnew file mode 100644index 0000000000..ce290c6d9d--- /dev/null+++ b/lib/plausible/funnels.ex@@ -0,0 +1,88 @@+defmodule Plausible.Funnels do+ @moduledoc """+ This module implements contextual Funnel interface, allowing listing,+ creating and deleting funnel definitions.++ For brief explanation of what a Funnel is, please see `Plausible.Funnel` schema.+ See `Plausible.Stats.Funnel` for the evaluation logic.+ """++ use Plausible.Funnel++ alias Plausible.Repo++ import Ecto.Query++ @spec create(Plausible.Site.t(), String.t(), [Plausible.Goal.t()]) ::+ {:ok, Funnel.t()}+ | {:error, Ecto.Changeset.t() | :invalid_funnel_size}+ def create(site, name, steps)+ when is_list(steps) and length(steps) in Funnel.min_steps()..Funnel.max_steps() do+ site+ |> create_changeset(name, steps)+ |> Repo.insert()+ end++ def create(_site, _name, _goals) do+ {:error, :invalid_funnel_size}+ end++ @spec create_changeset(Plausible.Site.t(), String.t(), [Plausible.Goal.t()]) ::+ Ecto.Changeset.t()+ def create_changeset(site, name, steps) do+ Funnel.changeset(%Funnel{site_id: site.id}, %{name: name, steps: steps})+ end++ @spec ephemeral_definition(Plausible.Site.t(), String.t(), [Plausible.Goal.t()]) :: Funnel.t()+ def ephemeral_definition(site, name, steps) do+ site+ |> create_changeset(name, steps)+ |> Ecto.Changeset.apply_changes()+ end++ @spec list(Plausible.Site.t()) :: [+ %{name: String.t(), id: pos_integer(), steps_count: pos_integer()}+ ]+ def list(%Plausible.Site{id: site_id}) do+ Repo.all(+ from f in Funnel,+ inner_join: steps in assoc(f, :steps),+ where: f.site_id == ^site_id,+ select: %{name: f.name, id: f.id, steps_count: count(steps)},+ group_by: f.id,+ order_by: [desc: :id]+ )+ end++ @spec delete(Plausible.Site.t(), pos_integer()) :: :ok+ def delete(%Plausible.Site{id: site_id}, funnel_id) do+ Repo.delete_all(+ from f in Funnel,+ where: f.site_id == ^site_id,+ where: f.id == ^funnel_id+ )++ :ok+ end++ @spec get(Plausible.Site.t() | pos_integer(), pos_integer()) ::+ Funnel.t() | nil+ def get(%Plausible.Site{id: site_id}, by) do+ get(site_id, by)+ end++ def get(site_id, funnel_id) when is_integer(site_id) and is_integer(funnel_id) do+ q =+ from f in Funnel,+ where: f.site_id == ^site_id,+ where: f.id == ^funnel_id,+ inner_join: steps in assoc(f, :steps),+ inner_join: goal in assoc(steps, :goal),+ order_by: steps.step_order,+ preload: [+ steps: {steps, goal: goal}+ ]++ Repo.one(q)+ end+enddiff --git a/lib/plausible/goal/schema.ex b/lib/plausible/goal/schema.exindex 02a58ad1dd..59b711dc64 100644--- a/lib/plausible/goal/schema.ex+++ b/lib/plausible/goal/schema.ex@@ -1,31 +1,16 @@-defimpl Jason.Encoder, for: Plausible.Goal do- def encode(value, opts) do- goal_type =- cond do- value.event_name -> :event- value.page_path -> :page- end-- domain = value.site.domain-- value- |> Map.put(:goal_type, goal_type)- |> Map.take([:id, :goal_type, :event_name, :page_path])- |> Map.put(:domain, domain)- |> Jason.Encode.map(opts)- end-end-defmodule Plausible.Goal douse Ecto.Schemaimport Ecto.Changeset+ @type t() :: %__MODULE__{}+schema "goals" dofield :event_name, :stringfield :page_path, :string-field :currency, Ecto.Enum, values: Money.Currency.known_current_currencies()+ many_to_many :funnels, Plausible.Funnel, join_through: Plausible.Funnel.Step+belongs_to :site, Plausible.Sitetimestamps()@@ -50,7 +35,7 @@ defmodule Plausible.Goal dodef changeset(goal, attrs \\ %{}) dogoal- |> cast(attrs, [:site_id, :event_name, :page_path, :currency])+ |> cast(attrs, [:id, :site_id, :event_name, :page_path, :currency])|> validate_required([:site_id])|> cast_assoc(:site)|> validate_event_name_and_page_path()@@ -88,3 +73,37 @@ defmodule Plausible.Goal doendendend++defimpl Jason.Encoder, for: Plausible.Goal do+ def encode(value, opts) do+ goal_type =+ cond do+ value.event_name -> :event+ value.page_path -> :page+ end++ domain = value.site.domain++ value+ |> Map.put(:goal_type, goal_type)+ |> Map.take([:id, :goal_type, :event_name, :page_path])+ |> Map.put(:domain, domain)+ |> Jason.Encode.map(opts)+ end+end++defimpl String.Chars, for: Plausible.Goal do+ def to_string(%{page_path: page_path}) when is_binary(page_path) do+ "Visit " <> page_path+ end++ def to_string(%{event_name: name}) when is_binary(name) do+ name+ end+end++defimpl Phoenix.HTML.Safe, for: Plausible.Goal do+ def to_iodata(data) do+ data |> to_string() |> Phoenix.HTML.Engine.html_escape()+ end+enddiff --git a/lib/plausible/goals.ex b/lib/plausible/goals.exindex 44a43e21ec..20c6fc78c6 100644--- a/lib/plausible/goals.ex+++ b/lib/plausible/goals.ex@@ -1,6 +1,9 @@defmodule Plausible.Goals douse Plausible.Repoalias Plausible.Goal+ alias Ecto.Multi++ use Plausible.Funneldef create(site, params) doparams = Map.merge(params, %{"site_id" => site.id})@@ -47,26 +50,93 @@ defmodule Plausible.Goals dodef find_or_create(_, %{"goal_type" => "page"}), do: {:missing, "page_path"}- def for_site(site) do+ def for_site(site, opts \\ []) doquery =from g in Goal,inner_join: assoc(g, :site),where: g.site_id == ^site.id,+ order_by: [desc: g.id],preload: [:site]+ query =+ if opts[:preload_funnels?] do+ from g in query,+ left_join: assoc(g, :funnels),+ group_by: g.id,+ preload: [:funnels]+ else+ query+ end+query|> Repo.all()|> Enum.map(&maybe_trim/1)end+ @doc """+ If a goal belongs to funnel(s), we need to inspect their number of steps.++ If it exceeds the minimum allowed (defined via `Plausible.Funnel.min_steps/0`),+ the funnel will be reduced (i.e. a step associated with the goal to be deleted+ is removed), so that the minimum number of steps is preserved. This is done+ implicitly, by postgres, as per on_delete: :delete_all.++ Otherwise, for associated funnel(s) consisting of minimum number steps only,+ funnel record(s) are removed completely along with the targeted goal.+ """def delete(id, site) do- case Repo.delete_all(- from g in Goal,- where: g.id == ^id,- where: g.site_id == ^site.id- ) do- {1, _} -> :ok- {0, _} -> {:error, :not_found}+ result =+ Multi.new()+ |> Multi.one(+ :goal,+ from(g in Goal,+ where: g.id == ^id,+ where: g.site_id == ^site.id,+ preload: [funnels: :steps]+ )+ )+ |> Multi.run(:funnel_ids_to_wipe, fn+ _, %{goal: nil} ->+ {:error, :not_found}++ _, %{goal: %{funnels: []}} ->+ {:ok, []}++ _, %{goal: %{funnels: funnels}} ->+ funnels_to_wipe =+ funnels+ |> Enum.filter(&(Enum.count(&1.steps) == Funnel.min_steps()))+ |> Enum.map(& &1.id)++ {:ok, funnels_to_wipe}+ end)+ |> Multi.merge(fn+ %{funnel_ids_to_wipe: []} ->+ Ecto.Multi.new()++ %{funnel_ids_to_wipe: [_ | _] = funnel_ids} ->+ Ecto.Multi.new()+ |> Multi.delete_all(+ :delete_funnels,+ from(f in Funnel,+ where: f.id in ^funnel_ids+ )+ )+ end)+ |> Multi.delete_all(+ :delete_goals,+ fn _ ->+ from(g in Goal,+ where: g.id == ^id,+ where: g.site_id == ^site.id+ )+ end+ )+ |> Repo.transaction()++ case result do+ {:ok, _} -> :ok+ {:error, _step, reason, _context} -> {:error, reason}endenddiff --git a/lib/plausible/stats/mod.ex b/lib/plausible/stats.exsimilarity index 87%rename from lib/plausible/stats/mod.exrename to lib/plausible/stats.exindex 704e05cb48..178955f302 100644--- a/lib/plausible/stats/mod.ex+++ b/lib/plausible/stats.ex@@ -3,6 +3,7 @@ defmodule Plausible.Stats dodefdelegate aggregate(site, query, metrics), to: Plausible.Stats.Aggregatedefdelegate timeseries(site, query, metrics), to: Plausible.Stats.Timeseriesdefdelegate current_visitors(site), to: Plausible.Stats.CurrentVisitors+ defdelegate funnel(site, query, funnel), to: Plausible.Stats.Funneldefdelegate filter_suggestions(site, query, filter_name, filter_search),to: Plausible.Stats.FilterSuggestionsdiff --git a/lib/plausible/stats/funnel.ex b/lib/plausible/stats/funnel.exnew file mode 100644index 0000000000..51b0ab9ca9--- /dev/null+++ b/lib/plausible/stats/funnel.ex@@ -0,0 +1,154 @@+defmodule Plausible.Stats.Funnel do+ @moduledoc """+ Module responsible for funnel evaluation, i.e. building and executing+ ClickHouse funnel query based on `Plausible.Funnel` definition.+ """++ @funnel_window_duration 86_400++ alias Plausible.Funnel+ alias Plausible.Funnels++ import Ecto.Query++ alias Plausible.ClickhouseRepo+ alias Plausible.Stats.Base++ @spec funnel(Plausible.Site.t(), Plausible.Stats.Query.t(), Funnel.t() | pos_integer()) ::+ {:ok, Funnel.t()} | {:error, :funnel_not_found}+ def funnel(site, query, funnel_id) when is_integer(funnel_id) do+ case Funnels.get(site.id, funnel_id) do+ %Funnel{} = funnel ->+ funnel(site, query, funnel)++ nil ->+ {:error, :funnel_not_found}+ end+ end++ def funnel(site, query, %Funnel{} = funnel) do+ steps =+ site+ |> Base.base_event_query(query)+ |> query_funnel(funnel)+ |> backfill_steps(funnel)++ {:ok,+ %{+ name: funnel.name,+ steps: steps+ }}+ end++ defp query_funnel(query, funnel_definition) do+ q_events =+ from(e in query,+ select: %{session_id: e.session_id},+ where: e.site_id == ^funnel_definition.site_id,+ group_by: e.session_id,+ having: fragment("step > 0"),+ order_by: [desc: fragment("step")]+ )+ |> select_funnel(funnel_definition)++ query =+ from f in subquery(q_events),+ select: {f.step, count(1)},+ group_by: f.step++ ClickhouseRepo.all(query)+ end++ defp select_funnel(db_query, funnel_definition) do+ window_funnel_steps =+ Enum.reduce(funnel_definition.steps, nil, fn step, acc ->+ step_condition = step_condition(step.goal)++ if acc do+ dynamic([q], fragment("?, ?", ^acc, ^step_condition))+ else+ dynamic([q], fragment("?", ^step_condition))+ end+ end)++ dynamic_window_funnel =+ dynamic(+ [q],+ fragment("windowFunnel(?)(timestamp, ?)", @funnel_window_duration, ^window_funnel_steps)+ )++ from q in db_query,+ select_merge:+ ^%{+ step: dynamic_window_funnel+ }+ end++ defp step_condition(goal) do+ case goal do+ %Plausible.Goal{event_name: event} when is_binary(event) ->+ dynamic([], fragment("name = ?", ^event))++ %Plausible.Goal{page_path: pathname} when is_binary(pathname) ->+ if String.contains?(pathname, "*") do+ regex = Plausible.Stats.Base.page_regex(pathname)+ dynamic([], fragment("match(pathname, ?)", ^regex))+ else+ dynamic([], fragment("pathname = ?", ^pathname))+ end+ end+ end++ defp backfill_steps(funnel_result, funnel) do+ # Directly from ClickHouse we only get {step_idx(), visitor_count()} tuples.+ # but no totals including previous steps are aggregated.+ # Hence we need to perform the appropriate backfill+ # and also calculate dropoff and conversion rate for each step.+ funnel_result = Enum.into(funnel_result, %{})+ max_step = Enum.max_by(funnel.steps, & &1.step_order).step_order++ funnel+ |> Map.fetch!(:steps)+ |> Enum.reduce({nil, nil, []}, fn step, {total_visitors, visitors_at_previous, acc} ->+ # first step contains the total number of all visitors qualifying for the funnel,+ # with each subsequent step needing to accumulate sum of the previous one(s)+ visitors_at_step =+ step.step_order..max_step+ |> Enum.map(&Map.get(funnel_result, &1, 0))+ |> Enum.sum()++ # accumulate current_visitors for the next iteration+ current_visitors = visitors_at_step++ # First step contains the total number of visitors that we base percentage dropoff on+ total_visitors =+ total_visitors ||+ current_visitors++ # Dropoff is 0 for the first step, otherwise we subtract current from previous+ dropoff = if visitors_at_previous, do: visitors_at_previous - current_visitors, else: 0++ conversion_rate =+ if current_visitors == 0 or total_visitors == 0 do+ "0.00"+ else+ current_visitors+ |> Decimal.div(total_visitors)+ |> Decimal.mult(100)+ |> Decimal.round(2)+ |> Decimal.to_string()+ end++ step = %{+ dropoff: dropoff,+ conversion_rate: conversion_rate,+ visitors: visitors_at_step,+ label: to_string(step.goal)+ }++ {total_visitors, current_visitors, [step | acc]}+ end)+ |> elem(2)+ |> Enum.reverse()+ end+enddiff --git a/priv/repo/seeds.exs b/priv/repo/seeds.exsindex b92dc09011..79ae8b7867 100644--- a/priv/repo/seeds.exs+++ b/priv/repo/seeds.exs@@ -12,6 +12,8 @@user = Plausible.Factory.insert(:user, email: "[email protected]", password: "plausible")+FunWithFlags.enable(:funnels)+native_stats_range =Date.range(Date.add(Date.utc_today(), -720),@@ -31,6 +33,17 @@ site =stats_start_date: NaiveDateTime.new!(imported_stats_range.first, ~T[00:00:00]))+{:ok, goal1} = Plausible.Goals.create(site, %{"page_path" => "/"})+{:ok, goal2} = Plausible.Goals.create(site, %{"page_path" => "/register"})+{:ok, goal3} = Plausible.Goals.create(site, %{"page_path" => "/login"})++{:ok, _funnel} =+ Plausible.Funnels.create(site, "From homepage to login", [+ %{"goal_id" => goal1.id},+ %{"goal_id" => goal2.id},+ %{"goal_id" => goal3.id}+ ])+_membership = Plausible.Factory.insert(:site_membership, user: user, site: site, role: :owner)put_random_time = fn@@ -94,7 +107,7 @@ geolocations = [native_stats_range|> Enum.with_index()|> Enum.flat_map(fn {date, index} ->- Enum.map(0..:rand.uniform(500), fn _ ->+ Enum.map(0..Enum.random(1..500), fn _ ->geolocation = Enum.random(geolocations)[@@ -108,7 +121,8 @@ native_stats_rangeoperating_system: Enum.random(["Windows", "macOS", "Linux"]),operating_system_version: to_string(Enum.random(0..15)),pathname:- Enum.random(["/", "/login", "/settings", "/register", "/docs", "/docs/1", "/docs/2"])+ Enum.random(["/", "/login", "/settings", "/register", "/docs", "/docs/1", "/docs/2"]),+ user_id: Enum.random(1..1200)]|> Keyword.merge(geolocation)|> then(&Plausible.Factory.build(:pageview, &1))@@ -127,7 +141,7 @@ site =imported_stats_range|> Enum.flat_map(fn date ->- Enum.flat_map(0..:rand.uniform(500), fn _ ->+ Enum.flat_map(0..Enum.random(1..500), fn _ ->[Plausible.Factory.build(:imported_visitors,date: date,diff --git a/test/plausible/funnels_test.exs b/test/plausible/funnels_test.exsnew file mode 100644index 0000000000..52b5513b53--- /dev/null+++ b/test/plausible/funnels_test.exs@@ -0,0 +1,252 @@+defmodule Plausible.FunnelsTest do+ use Plausible.DataCase++ alias Plausible.Goals+ alias Plausible.Funnels+ alias Plausible.Stats++ setup do+ site = insert(:site)++ {:ok, g1} = Goals.create(site, %{"page_path" => "/go/to/blog/**"})+ {:ok, g2} = Goals.create(site, %{"event_name" => "Signup"})+ {:ok, g3} = Goals.create(site, %{"page_path" => "/checkout"})+ {:ok, g4} = Goals.create(site, %{"event_name" => "Leave feedback"})+ {:ok, g5} = Goals.create(site, %{"page_path" => "/recommend"})+ {:ok, g6} = Goals.create(site, %{"event_name" => "Extra event"})++ {:ok,+ %{+ site: site,+ goals: [g1, g2, g3],+ steps: [g1, g2, g3, g4, g5, g6] |> Enum.map(&%{"goal_id" => &1.id})+ }}+ end++ describe "Common context" do+ test "create and store a funnel given a set of goals", %{site: site, steps: [g1, g2, g3 | _]} do+ {:ok, funnel} =+ Funnels.create(+ site,+ "From blog to signup and purchase",+ [g1, g2, g3]+ )++ assert funnel.inserted_at+ assert funnel.name == "From blog to signup and purchase"+ assert [fg1, fg2, fg3] = funnel.steps++ assert fg1.goal_id == g1["goal_id"]+ assert fg2.goal_id == g2["goal_id"]+ assert fg3.goal_id == g3["goal_id"]++ assert fg1.step_order == 1+ assert fg2.step_order == 2+ assert fg3.step_order == 3+ end++ test "retrieve a funnel by id and site, get steps in order", %{+ site: site,+ steps: [g1, g2, g3 | _]+ } do+ {:ok, funnel} =+ Funnels.create(+ site,+ "Lorem ipsum",+ [g3, g1, g2]+ )++ assert funnel = Funnels.get(site, funnel.id)+ assert funnel.name == "Lorem ipsum"+ assert [%{step_order: 1}, %{step_order: 2}, %{step_order: 3}] = funnel.steps+ end++ test "funnels can be deleted by id and a site", %{site: site, steps: [g1, g2 | _]} do+ {:ok, funnel} =+ Funnels.create(+ site,+ "Sample funnel",+ [g1, g2]+ )++ assert :ok = Funnels.delete(site, funnel.id)+ # deletion is idempotent+ assert :ok = Funnels.delete(site, funnel.id)+ refute Funnels.get(site, funnel.id)+ end++ test "a funnel cannot be made of < 2 steps", %{site: site, steps: [g1 | _]} do+ assert {:error, :invalid_funnel_size} =+ Funnels.create(+ site,+ "Lorem ipsum",+ [g1]+ )+ end++ test "a funnel can be made of 5 steps maximum", %{site: site, steps: too_many_steps} do+ assert {:error, :invalid_funnel_size} =+ Funnels.create(+ site,+ "Lorem ipsum",+ too_many_steps+ )+ end++ test "a goal can only appear once in a funnel", %{steps: [g1 | _], site: site} do+ {:error, _changeset} =+ Funnels.create(+ site,+ "Lorem ipsum",+ [g1, g1]+ )+ end++ test "funnels can be listed per site, starting from most recently added", %{+ site: site,+ steps: [g1, g2, g3 | _]+ } do+ Funnels.create(site, "Funnel 1", [g3, g1])+ Funnels.create(site, "Funnel 2", [g2, g1, g3])++ funnels_list = Funnels.list(site)++ assert [%{name: "Funnel 2", steps_count: 3}, %{name: "Funnel 1", steps_count: 2}] =+ funnels_list+ end+ end++ describe "Plausible.Stats.Funnel" do+ test "funnels can be evaluated per site within a time range against an ephemeral definition",+ %{+ site: site,+ goals: [g1, g2, g3 | _]+ } do+ funnel_definition =+ Funnels.ephemeral_definition(+ site,+ "From blog to signup and purchase",+ [+ %{+ "goal_id" => "#{g1.id}",+ "goal" => %{+ "id" => "#{g1.id}",+ "event_name" => g1.event_name,+ "page_path" => g1.page_path+ }+ },+ %{+ "goal_id" => g2.id,+ "goal" => %{+ "id" => g2.id,+ "event_name" => g2.event_name,+ "page_path" => g2.page_path+ }+ },+ %{+ "goal_id" => g3.id,+ "goal" => %{+ "id" => g3.id,+ "event_name" => g3.event_name,+ "page_path" => g3.page_path+ }+ }+ ]+ )++ populate_stats(site, [+ build(:pageview, pathname: "/go/to/blog/foo", user_id: 123),+ build(:event, name: "Signup", user_id: 123),+ build(:pageview, pathname: "/checkout", user_id: 123),+ build(:pageview, pathname: "/go/to/blog/bar", user_id: 666),+ build(:event, name: "Signup", user_id: 666)+ ])++ query = Plausible.Stats.Query.from(site, %{"period" => "all"})++ funnel_data = Stats.funnel(site, query, funnel_definition)++ assert {:ok,+ %{+ steps: [+ %{+ label: "Visit /go/to/blog/**",+ visitors: 2,+ conversion_rate: "100.00",+ dropoff: 0+ },+ %{label: "Signup", visitors: 2, conversion_rate: "100.00", dropoff: 0},+ %{label: "Visit /checkout", visitors: 1, conversion_rate: "50.00", dropoff: 1}+ ]+ }} = funnel_data+ end++ test "funnels can be evaluated per site within a time range", %{+ site: site,+ steps: [g1, g2, g3 | _]+ } do+ {:ok, funnel} =+ Funnels.create(+ site,+ "From blog to signup and purchase",+ [g1, g2, g3]+ )++ populate_stats(site, [+ build(:pageview, pathname: "/go/to/blog/foo", user_id: 123),+ build(:event, name: "Signup", user_id: 123),+ build(:pageview, pathname: "/checkout", user_id: 123),+ build(:pageview, pathname: "/go/to/blog/bar", user_id: 666),+ build(:event, name: "Signup", user_id: 666)+ ])++ query = Plausible.Stats.Query.from(site, %{"period" => "all"})++ funnel_data = Stats.funnel(site, query, funnel.id)++ assert {:ok,+ %{+ steps: [+ %{+ label: "Visit /go/to/blog/**",+ visitors: 2,+ conversion_rate: "100.00",+ dropoff: 0+ },+ %{label: "Signup", visitors: 2, conversion_rate: "100.00", dropoff: 0},+ %{label: "Visit /checkout", visitors: 1, conversion_rate: "50.00", dropoff: 1}+ ]+ }} = funnel_data+ end++ test "funnels can be evaluated even where there are no visits yet", %{+ site: site,+ steps: [g1, g2, g3 | _]+ } do+ {:ok, funnel} =+ Funnels.create(+ site,+ "From blog to signup and purchase",+ [g1, g2, g3]+ )++ query = Plausible.Stats.Query.from(site, %{"period" => "all"})++ funnel_data = Stats.funnel(site, query, funnel.id)++ assert {:ok,+ %{+ steps: [+ %{+ label: "Visit /go/to/blog/**",+ visitors: 0,+ conversion_rate: "0.00",+ dropoff: 0+ },+ %{label: "Signup", visitors: 0, conversion_rate: "0.00", dropoff: 0},+ %{label: "Visit /checkout", visitors: 0, conversion_rate: "0.00", dropoff: 0}+ ]+ }} = funnel_data+ end+ end+enddiff --git a/test/plausible/goals_test.exs b/test/plausible/goals_test.exsindex 4e3f20dcda..2df4c2b782 100644--- a/test/plausible/goals_test.exs+++ b/test/plausible/goals_test.exs@@ -25,7 +25,7 @@ defmodule Plausible.GoalsTest dogoals = Goals.for_site(site)- assert [%{event_name: "Signup"}, %{page_path: "/Signup"}] = goals+ assert [%{page_path: "/Signup"}, %{event_name: "Signup"}] = goalsendtest "goals are present after domain change" do@@ -47,4 +47,86 @@ defmodule Plausible.GoalsTest doassert [] = Goals.for_site(site)end++ test "goals can be deleted" do+ site = insert(:site)+ goal = insert(:goal, %{site: site, event_name: " Signup "})+ :ok = Goals.delete(goal.id, site)+ assert [] = Goals.for_site(site)+ end++ test "goals can be fetched with funnel count preloaded" do+ site = insert(:site)++ goals =+ Enum.map(1..4, fn i ->+ {:ok, g} = Goals.create(site, %{"page_path" => "/#{i}"})+ g+ end)++ {:ok, %{id: funnel_id1}} =+ Plausible.Funnels.create(+ site,+ "Funnel1",+ [+ %{"goal_id" => Enum.at(goals, 1).id},+ %{"goal_id" => Enum.at(goals, 2).id},+ %{"goal_id" => Enum.at(goals, 3).id}+ ]+ )++ {:ok, %{id: funnel_id2}} =+ Plausible.Funnels.create(+ site,+ "Funnel2",+ [+ %{"goal_id" => Enum.at(goals, 1).id},+ %{"goal_id" => Enum.at(goals, 3).id}+ ]+ )++ assert [goal, _, _, _] = Goals.for_site(site, preload_funnels?: false)+ assert %Ecto.Association.NotLoaded{} = goal.funnels++ assert [goal, _, _, _] = Goals.for_site(site, preload_funnels?: true)+ assert [%{id: ^funnel_id1}, %{id: ^funnel_id2}] = goal.funnels+ end++ test "deleting goals with funnels triggers funnel reduction" do+ site = insert(:site)+ {:ok, g1} = Goals.create(site, %{"page_path" => "/1"})+ {:ok, g2} = Goals.create(site, %{"page_path" => "/2"})+ {:ok, g3} = Goals.create(site, %{"page_path" => "/3"})++ {:ok, f1} =+ Plausible.Funnels.create(+ site,+ "Funnel 3 steps",+ [+ %{"goal_id" => g1.id},+ %{"goal_id" => g2.id},+ %{"goal_id" => g3.id}+ ]+ )++ {:ok, f2} =+ Plausible.Funnels.create(+ site,+ "Funnel 2 steps",+ [+ %{"goal_id" => g1.id},+ %{"goal_id" => g2.id}+ ]+ )++ :ok = Goals.delete(g1.id, site)++ assert f1 = Plausible.Funnels.get(site.id, f1.id)+ assert Enum.count(f1.steps) == 2++ refute Plausible.Funnels.get(site.id, f2.id)+ assert Repo.all(from fs in Plausible.Funnel.Step, where: fs.funnel_id == ^f2.id) == []++ assert [^g3, ^g2] = Goals.for_site(site)+ endenddiff --git a/test/plausible_web/controllers/api/stats_controller/conversions_test.exs b/test/plausible_web/controllers/api/stats_controller/conversions_test.exsindex abbf82adaf..b939035caf 100644--- a/test/plausible_web/controllers/api/stats_controller/conversions_test.exs+++ b/test/plausible_web/controllers/api/stats_controller/conversions_test.exs@@ -1399,14 +1399,14 @@ defmodule PlausibleWeb.Api.StatsController.ConversionsTest do%{"conversion_rate" => 37.5,"unique_conversions" => 3,- "name" => "Visit /*",+ "name" => "Visit /signup/**","total_conversions" => 3,"prop_names" => []},%{"conversion_rate" => 37.5,"unique_conversions" => 3,- "name" => "Visit /signup/**",+ "name" => "Visit /*","total_conversions" => 3,"prop_names" => []},@@ -1427,21 +1427,21 @@ defmodule PlausibleWeb.Api.StatsController.ConversionsTest do%{"conversion_rate" => 12.5,"unique_conversions" => 1,- "name" => "Visit /billing*/success",+ "name" => "Visit /signup/*","total_conversions" => 1,"prop_names" => []},%{"conversion_rate" => 12.5,"unique_conversions" => 1,- "name" => "Visit /register",+ "name" => "Visit /billing*/success","total_conversions" => 1,"prop_names" => []},%{"conversion_rate" => 12.5,"unique_conversions" => 1,- "name" => "Visit /signup/*",+ "name" => "Visit /register","total_conversions" => 1,"prop_names" => []}