Skip to content

Open source, privacy-first web analytics. Lightweight, cookie-free Google Analytics alternative. Self-hosted or cloud.

Implement backend core for funnels (#3023)

hq1a356009af8cb
diff --git a/lib/plausible/funnel.ex b/lib/plausible/funnel.ex
new file mode 100644
index 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
+end
diff --git a/lib/plausible/funnel/step.ex b/lib/plausible/funnel/step.ex
new file mode 100644
index 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
+end
diff --git a/lib/plausible/funnels.ex b/lib/plausible/funnels.ex
new file mode 100644
index 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
+end
diff --git a/lib/plausible/goal/schema.ex b/lib/plausible/goal/schema.ex
index 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 do
use Ecto.Schema
import Ecto.Changeset
+ @type t() :: %__MODULE__{}
+
schema "goals" do
field :event_name, :string
field :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.Site
timestamps()
@@ -50,7 +35,7 @@ defmodule Plausible.Goal do
def changeset(goal, attrs \\ %{}) do
goal
- |> 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 do
end
end
end
+
+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
+end
diff --git a/lib/plausible/goals.ex b/lib/plausible/goals.ex
index 44a43e21ec..20c6fc78c6 100644
--- a/lib/plausible/goals.ex
+++ b/lib/plausible/goals.ex
@@ -1,6 +1,9 @@
defmodule Plausible.Goals do
use Plausible.Repo
alias Plausible.Goal
+ alias Ecto.Multi
+
+ use Plausible.Funnel
def create(site, params) do
params = Map.merge(params, %{"site_id" => site.id})
@@ -47,26 +50,93 @@ defmodule Plausible.Goals do
def find_or_create(_, %{"goal_type" => "page"}), do: {:missing, "page_path"}
- def for_site(site) do
+ def for_site(site, opts \\ []) do
query =
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}
end
end
diff --git a/lib/plausible/stats/mod.ex b/lib/plausible/stats.ex
similarity index 87%
rename from lib/plausible/stats/mod.ex
rename to lib/plausible/stats.ex
index 704e05cb48..178955f302 100644
--- a/lib/plausible/stats/mod.ex
+++ b/lib/plausible/stats.ex
@@ -3,6 +3,7 @@ defmodule Plausible.Stats do
defdelegate aggregate(site, query, metrics), to: Plausible.Stats.Aggregate
defdelegate timeseries(site, query, metrics), to: Plausible.Stats.Timeseries
defdelegate current_visitors(site), to: Plausible.Stats.CurrentVisitors
+ defdelegate funnel(site, query, funnel), to: Plausible.Stats.Funnel
defdelegate filter_suggestions(site, query, filter_name, filter_search),
to: Plausible.Stats.FilterSuggestions
diff --git a/lib/plausible/stats/funnel.ex b/lib/plausible/stats/funnel.ex
new file mode 100644
index 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
+end
diff --git a/priv/repo/seeds.exs b/priv/repo/seeds.exs
index 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_range
operating_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.exs
new file mode 100644
index 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
+end
diff --git a/test/plausible/goals_test.exs b/test/plausible/goals_test.exs
index 4e3f20dcda..2df4c2b782 100644
--- a/test/plausible/goals_test.exs
+++ b/test/plausible/goals_test.exs
@@ -25,7 +25,7 @@ defmodule Plausible.GoalsTest do
goals = Goals.for_site(site)
- assert [%{event_name: "Signup"}, %{page_path: "/Signup"}] = goals
+ assert [%{page_path: "/Signup"}, %{event_name: "Signup"}] = goals
end
test "goals are present after domain change" do
@@ -47,4 +47,86 @@ defmodule Plausible.GoalsTest do
assert [] = 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)
+ end
end
diff --git a/test/plausible_web/controllers/api/stats_controller/conversions_test.exs b/test/plausible_web/controllers/api/stats_controller/conversions_test.exs
index 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" => []
}