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
Stats: Rebuild session smearing for timeseries (#5694)
Karl-Aksel Puulmanndb448d740470
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 919ba21f8a..ba3930eafa 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -27,6 +27,9 @@ All notable changes to this project will be documented in this file.- Make clicking Compare / Disable Comparison in period picker menu close the menu- Do not log page views for hidden pages (prerendered pages and new tabs), until pages are viewed- Password-authenticated shared links now carry over dashboard params properly+- Realtime and hourly graphs of visit duration, views per visit no longer overcount due to long-lasting sessions, instead showing each visit+ when they occurred.+- Fixed realtime and hourly graphs of visits overcounting## v3.0.0 - 2025-04-11diff --git a/lib/plausible/stats/query.ex b/lib/plausible/stats/query.exindex 7b7a343c78..aabb61f26a 100644--- a/lib/plausible/stats/query.ex+++ b/lib/plausible/stats/query.ex@@ -28,7 +28,9 @@ defmodule Plausible.Stats.Query dosite_id: nil,site_native_stats_start_at: nil,# Contains information to determine how to combine legacy and new time on page metrics- time_on_page_data: %{}+ time_on_page_data: %{},+ sql_join_type: :left,+ smear_session_metrics: falserequire OpenTelemetry.Tracer, as: Traceralias Plausible.Stats.{DateTimeRange, Filters, Imported, Legacy, Comparisons}diff --git a/lib/plausible/stats/query_optimizer.ex b/lib/plausible/stats/query_optimizer.exindex 10734507d2..30e43bcef9 100644--- a/lib/plausible/stats/query_optimizer.ex+++ b/lib/plausible/stats/query_optimizer.ex@@ -26,6 +26,7 @@ defmodule Plausible.Stats.QueryOptimizer do4. Updates event:hostname filters to also apply on visit level for sane results.5. Removes revenue metrics from dashboard queries if not requested, present or unavailable for the site.6. Trims the date range to the current time if query.include.trim_relative_date_range is true.+ 7. Sets the join_type for the query based on the query."""def optimize(query) do@@ -40,18 +41,12 @@ defmodule Plausible.Stats.QueryOptimizer dofor sessions."""def split(query) do- {event_metrics, sessions_metrics, _other_metrics} =- query.metrics- |> Util.maybe_add_visitors_metric()- |> TableDecider.partition_metrics(query)-- {- Query.set(query,- metrics: event_metrics,- include_imported: query.include_imported- ),- split_sessions_query(query, sessions_metrics)- }+ query.metrics+ |> Util.maybe_add_visitors_metric()+ |> TableDecider.partition_metrics(query)+ |> Enum.map(fn {table_type, metrics} ->+ build_split_query(table_type, metrics, query)+ end)enddefp pipeline() do@@ -62,7 +57,8 @@ defmodule Plausible.Stats.QueryOptimizer do&extend_hostname_filters_to_visit/1,&remove_revenue_metrics_if_unavailable/1,&set_time_on_page_data/1,- &trim_relative_date_range/1+ &trim_relative_date_range/1,+ &set_sql_join_type/1]end@@ -162,7 +158,17 @@ defmodule Plausible.Stats.QueryOptimizer doEnum.find(query.dimensions, &Time.time_dimension?/1)end- defp split_sessions_query(query, session_metrics) do+ defp build_split_query(:events, metrics, query) do+ {+ :events,+ Query.set(query,+ metrics: metrics,+ include_imported: query.include_imported+ )+ }+ end++ defp build_split_query(:sessions, metrics, query) dodimensions =query.dimensions|> Enum.map(fn@@ -179,12 +185,21 @@ defmodule Plausible.Stats.QueryOptimizer doquery.filtersend- Query.set(query,- filters: filters,- metrics: session_metrics,- dimensions: dimensions,- include_imported: query.include_imported- )+ {+ :sessions,+ Query.set(query,+ filters: filters,+ metrics: metrics,+ dimensions: dimensions,+ include_imported: query.include_imported+ )+ }+ end++ defp build_split_query(:sessions_smeared, metrics, query) do+ {_, query} = build_split_query(:sessions, metrics, query)++ {:sessions, Query.set(query, smear_session_metrics: true)}endon_ee do@@ -299,4 +314,19 @@ defmodule Plausible.Stats.QueryOptimizer do|> DateTimeRange.to_timezone("Etc/UTC")endend++ # Normally we can always LEFT JOIN as this is more performant and tables+ # are expected to contain the same dimensions.++ # The only exception is using the "time:minute" dimension where the sessions+ # subquery might return more rows than the events one. That's because we're+ # counting sessions in all time buckets they were active in even if no event+ # occurred during that particular minute.+ defp set_sql_join_type(query) do+ if "time:minute" in query.dimensions do+ Query.set(query, sql_join_type: :full)+ else+ query+ end+ endenddiff --git a/lib/plausible/stats/sql/expression.ex b/lib/plausible/stats/sql/expression.exindex 9c01185ec8..f03f487d58 100644--- a/lib/plausible/stats/sql/expression.ex+++ b/lib/plausible/stats/sql/expression.ex@@ -64,7 +64,7 @@ defmodule Plausible.Stats.SQL.Expression do})end- def select_dimension(q, key, "time:hour", :sessions, query) do+ def select_dimension(q, key, "time:hour", :sessions, query) when query.smear_session_metrics do# :TRICKY: ClickHouse timeSlots works off of unix epoch and is not# timezone-aware. This means that for e.g. Asia/Katmandu (GMT+5:45)# to work, we divide time into 15-minute buckets and later combine these@@ -87,7 +87,8 @@ defmodule Plausible.Stats.SQL.Expression doend# :NOTE: This is not exposed in Query APIv2- def select_dimension(q, key, "time:minute", :sessions, query) do+ def select_dimension(q, key, "time:minute", :sessions, query)+ when query.smear_session_metrics doq|> join(:inner, [s], time_slot in time_slots(query, 60),as: :time_slot,@@ -338,6 +339,12 @@ defmodule Plausible.Stats.SQL.Expression do})end+ def session_metric(:visits, query) when query.smear_session_metrics do+ wrap_alias([s], %{+ visits: scale_sample(fragment("uniq(?)", s.session_id))+ })+ end+def session_metric(:visits, _query) dowrap_alias([s], %{visits: scale_sample(fragment("greatest(sum(?), 0)", s.sign))diff --git a/lib/plausible/stats/sql/query_builder.ex b/lib/plausible/stats/sql/query_builder.exindex 74361d5afd..ae8deb74f3 100644--- a/lib/plausible/stats/sql/query_builder.ex+++ b/lib/plausible/stats/sql/query_builder.ex@@ -15,15 +15,14 @@ defmodule Plausible.Stats.SQL.QueryBuilder dorequire Plausible.Stats.SQL.Expressiondef build(query, site) do- {event_query, sessions_query} = QueryOptimizer.split(query)-- event_q = build_events_query(site, event_query)- sessions_q = build_sessions_query(site, sessions_query)-- join_query_results(- {event_q, event_query},- {sessions_q, sessions_query}- )+ query+ |> QueryOptimizer.split()+ |> Enum.map(fn {table_type, table_query} ->+ q = build_table_query(table_type, site, table_query)+ {table_type, table_query, q}+ end)+ |> join_query_results(query)+ |> build_order_by(query)|> paginate(query.pagination)|> select_total_rows(query.include.total_rows)end@@ -32,9 +31,7 @@ defmodule Plausible.Stats.SQL.QueryBuilder doEnum.reduce(query.order_by || [], q, &build_order_by(&2, query, &1))end- defp build_events_query(_site, %Query{metrics: []}), do: nil-- defp build_events_query(site, events_query) do+ defp build_table_query(:events, site, events_query) doq =from(e in "events_v2",@@ -54,6 +51,25 @@ defmodule Plausible.Stats.SQL.QueryBuilder do|> TimeOnPage.merge_legacy_time_on_page(events_query)end+ defp build_table_query(:sessions, site, sessions_query) do+ q =+ from(+ e in "sessions_v2",+ where: ^SQL.WhereBuilder.build(:sessions, sessions_query),+ select: ^select_session_metrics(sessions_query)+ )++ on_ee do+ q = Plausible.Stats.Sampling.add_query_hint(q, sessions_query)+ end++ q+ |> join_events_if_needed(sessions_query)+ |> build_group_by(:sessions, sessions_query)+ |> merge_imported(site, sessions_query)+ |> SQL.SpecialMetrics.add(site, sessions_query)+ end+defp join_sessions_if_needed(q, query) doif TableDecider.events_join_sessions?(query) dosessions_q =@@ -79,27 +95,6 @@ defmodule Plausible.Stats.SQL.QueryBuilder doendend- defp build_sessions_query(_site, %Query{metrics: []}), do: nil-- defp build_sessions_query(site, sessions_query) do- q =- from(- e in "sessions_v2",- where: ^SQL.WhereBuilder.build(:sessions, sessions_query),- select: ^select_session_metrics(sessions_query)- )-- on_ee do- q = Plausible.Stats.Sampling.add_query_hint(q, sessions_query)- end-- q- |> join_events_if_needed(sessions_query)- |> build_group_by(:sessions, sessions_query)- |> merge_imported(site, sessions_query)- |> SQL.SpecialMetrics.add(site, sessions_query)- end-def join_events_if_needed(q, query) doif TableDecider.sessions_join_events?(query) doevents_q =@@ -173,24 +168,24 @@ defmodule Plausible.Stats.SQL.QueryBuilder do)end- defp join_query_results({nil, _}, {nil, _}), do: nil-- defp join_query_results({events_q, events_query}, {nil, _}),- do: events_q |> build_order_by(events_query)+ # Only one table is being queried - skip joining!+ defp join_query_results([{_table_type, _query, q}], _main_query), do: q- defp join_query_results({nil, events_query}, {sessions_q, _}),- do: sessions_q |> build_order_by(events_query)+ # Multiple tables: join results based on dimensions, select metrics from each and the appropriate dimensions.+ defp join_query_results(queries, main_query) do+ queries+ |> Enum.reduce(nil, fn+ {_table_type, query, q}, nil ->+ from(e in subquery(q))+ |> select_join_metrics(query, query.metrics)- defp join_query_results({events_q, events_query}, {sessions_q, sessions_query}) do- {join_type, events_q_fields, sessions_q_fields} =- TableDecider.join_options(events_query, sessions_query)-- join(subquery(events_q), join_type, [e], s in subquery(sessions_q),- on: ^build_group_by_join(events_query)- )- |> select_join_fields(events_query, events_q_fields, e)- |> select_join_fields(sessions_query, sessions_q_fields, s)- |> build_order_by(events_query)+ {_table_type, query, q}, acc ->+ join(acc, main_query.sql_join_type, [], s in subquery(q),+ on: ^build_group_by_join(main_query)+ )+ |> select_join_metrics(query, query.metrics -- [:sample_percent])+ end)+ |> select_dimensions(main_query)end# NOTE: Old queries do their own pagination@@ -214,8 +209,33 @@ defmodule Plausible.Stats.SQL.QueryBuilder dodef build_group_by_join(query) doquery.dimensions|> Enum.map(fn dim ->- dynamic([e, s], field(e, ^shortname(query, dim)) == field(s, ^shortname(query, dim)))+ dynamic([a, ..., b], field(a, ^shortname(query, dim)) == field(b, ^shortname(query, dim)))end)|> Enum.reduce(fn condition, acc -> dynamic([], ^acc and ^condition) end)end++ defp select_join_metrics(q, query, metrics) do+ Enum.reduce(metrics, q, fn+ metric, q ->+ select_merge_as(q, [..., x], %{+ shortname(query, metric) => field(x, ^shortname(query, metric))+ })+ end)+ end++ defp select_dimensions(q, query) do+ Enum.reduce(query.dimensions, q, fn dimension, q ->+ # We generally select dimensions from the left-most table. Only exception is time:minute where+ # we use sessions table as sessions are considered on-going during the whole period.+ if query.sql_join_type == :full and "time:minute" == dimension do+ select_merge_as(q, [..., x], %{+ shortname(query, dimension) => field(x, ^shortname(query, dimension))+ })+ else+ select_merge_as(q, [x], %{+ shortname(query, dimension) => field(x, ^shortname(query, dimension))+ })+ end+ end)+ endenddiff --git a/lib/plausible/stats/table_decider.ex b/lib/plausible/stats/table_decider.exindex 8613c83aab..25bd03c386 100644--- a/lib/plausible/stats/table_decider.ex+++ b/lib/plausible/stats/table_decider.ex@@ -54,84 +54,73 @@ defmodule Plausible.Stats.TableDecider doendend- @doc """- Returns a three-element tuple with instructions on how to join two Ecto- queries. The arguments (`events_query` and `sessions_query`) are `%Query{}`- structs that have been split by TableDecider already.-- Normally we can always LEFT JOIN sessions to events, selecting `dimensions`- only from the events subquery. That's because:-- 1) session dimensions (e.g. entry_page) cannot be queried alongside event- metrics/dimensions, or-- 2) session dimensions (e.g. operating_system) are also available in the- events table.+ @type table_type() :: :events | :sessions+ @type metric() :: String.t()- The only exception is using the "time:minute" dimension where the sessions- subquery might return more rows than the events one. That's because we're- counting sessions in all time buckets they were active in.- """- def join_options(events_query, sessions_query) do- events_q_select_fields = events_query.metrics ++ events_query.dimensions- sessions_q_select_fields = sessions_query.metrics -- [:sample_percent]-- if "time:minute" in events_query.dimensions do- {- :full,- events_q_select_fields -- ["time:minute"],- sessions_q_select_fields ++ ["time:minute"]- }- else- {:left, events_q_select_fields, sessions_q_select_fields}- end- end+ @spec partition_metrics(list(metric()), Query.t()) :: list({table_type(), list(metric())})+ def partition_metrics(requested_metrics, query) do+ metrics = partition(requested_metrics, query, &metric_partitioner/2)- def partition_metrics(metrics, query) do- %{- event: event_only_metrics,- session: session_only_metrics,- either: either_metrics,- other: other_metrics,- sample_percent: sample_percent- } =- partition(metrics, query, &metric_partitioner/2)-- %{event: event_only_filters, session: session_only_filters} =+ filters =query.filters|> dimensions_used_in_filters()|> partition(query, &dimension_partitioner/2)- %{event: event_only_dimensions, session: session_only_dimensions} =- partition(query.dimensions, query, &dimension_partitioner/2)+ dimensions = partition(query.dimensions, query, &dimension_partitioner/2)cond do# Only one table needs to be queried- empty?(event_only_metrics) && empty?(event_only_filters) && empty?(event_only_dimensions) ->- {[], session_only_metrics ++ either_metrics ++ sample_percent, other_metrics}+ empty?(metrics.event) && empty?(filters.event) && empty?(dimensions.event) ->+ [sessions: metrics.session ++ metrics.either ++ metrics.sample_percent]- empty?(session_only_metrics) && empty?(session_only_filters) &&- empty?(session_only_dimensions) ->- {event_only_metrics ++ either_metrics ++ sample_percent, [], other_metrics}+ empty?(metrics.session) && empty?(filters.session) && empty?(dimensions.session) ->+ [events: metrics.event ++ metrics.either ++ metrics.sample_percent]# Filters and/or dimensions on both events and sessions, but only one kind of metric- empty?(event_only_metrics) && empty?(event_only_dimensions) ->- {[], session_only_metrics ++ either_metrics ++ sample_percent, other_metrics}+ empty?(metrics.event) && empty?(dimensions.event) ->+ [sessions: metrics.session ++ metrics.either ++ metrics.sample_percent]- empty?(session_only_metrics) && empty?(session_only_dimensions) ->- {event_only_metrics ++ either_metrics ++ sample_percent, [], other_metrics}+ empty?(metrics.session) && empty?(dimensions.session) ->+ [events: metrics.event ++ metrics.either ++ metrics.sample_percent]# Default: prefer eventstrue ->- {event_only_metrics ++ either_metrics ++ sample_percent,- session_only_metrics ++ sample_percent, other_metrics}+ [+ events: metrics.event ++ metrics.either ++ metrics.sample_percent,+ sessions: metrics.session ++ metrics.sample_percent+ ]end+ |> Enum.flat_map(&smear_session_metrics(&1, query))+ |> Enum.reject(fn {_table_type, metrics} -> empty?(metrics) end)end+ # :TRICKY: When counting session metrics, we want to count each visit/visitor across+ # the length of the session, not just when events occurred or when session started.+ # For this reason, we smear the session metrics across the length of the session.+ # See `time_slots` usage in `Plausible.Stats.SQL.Expression` to understand how this is done.+ @smearable_metrics [:visitors, :visits]+ defp smear_session_metrics({:sessions, metrics} = value, query) do+ if "time:minute" in query.dimensions or "time:hour" in query.dimensions do+ # Split metrics into two groups: one with visitors and visits, and the remaining ones+ {smearable_metrics, session_metrics} = Enum.split_with(metrics, &(&1 in @smearable_metrics))++ [+ {:sessions, session_metrics},+ {:sessions_smeared, smearable_metrics}+ ]+ else+ [value]+ end+ end++ defp smear_session_metrics(value, _query), do: [value]+# Note: This is inaccurate when filtering but required for old backwards compatibilitydefp metric_partitioner(%Query{legacy_breakdown: true}, :pageviews), do: :eitherdefp metric_partitioner(%Query{legacy_breakdown: true}, :events), do: :either+ # :TRICKY: For time:minute dimension we prefer sessions over events as there+ # might be minutes where no events occurred but the session was active.defp metric_partitioner(query, metric) when metric in [:visitors, :visits] doif "time:minute" in query.dimensions, do: :session, else: :eitherenddiff --git a/test/plausible/stats/query_optimizer_test.exs b/test/plausible/stats/query_optimizer_test.exsindex 24dfc22d78..e7e5bd27fd 100644--- a/test/plausible/stats/query_optimizer_test.exs+++ b/test/plausible/stats/query_optimizer_test.exs@@ -363,4 +363,14 @@ defmodule Plausible.Stats.QueryOptimizerTest doassert result.utc_time_range.last == nyc_mar_15_endendend++ describe "set_sql_join_type" do+ test "updates sql_join_type to :full if time:minute dimension is present" do+ assert perform(%{dimensions: ["time:minute"]}).sql_join_type == :full+ end++ test "keeps default sql_join_type otherwise" do+ assert perform(%{dimensions: ["time:hour"]}).sql_join_type == :left+ end+ endenddiff --git a/test/plausible/stats/table_decider_test.exs b/test/plausible/stats/table_decider_test.exsindex 1ba7768f9b..d30beb5669 100644--- a/test/plausible/stats/table_decider_test.exs+++ b/test/plausible/stats/table_decider_test.exs@@ -28,127 +28,164 @@ defmodule Plausible.Stats.TableDeciderTest dotest "with no metrics or filters" doquery = make_query([])- assert partition_metrics([], query) == {[], [], []}+ assert partition_metrics([], query) == []endtest "session-only metrics accordingly" doquery = make_query([])- assert partition_metrics([:bounce_rate, :views_per_visit], query) ==- {[], [:bounce_rate, :views_per_visit], []}+ assert partition_metrics([:bounce_rate, :views_per_visit], query) == [+ sessions: [:bounce_rate, :views_per_visit]+ ]endtest "event-only metrics accordingly" doquery = make_query([])- assert partition_metrics([:total_revenue, :visitors], query) ==- {[:total_revenue, :visitors], [], []}+ assert partition_metrics([:total_revenue, :visitors], query) == [+ events: [:total_revenue, :visitors]+ ]endtest "filters from both, event-only metrics" doquery = make_query(["event:name", "visit:source"])- assert partition_metrics([:total_revenue], query) == {[:total_revenue], [], []}+ assert partition_metrics([:total_revenue], query) == [events: [:total_revenue]]endtest "filters from both, session-only metrics" doquery = make_query(["event:name", "visit:source"])- assert partition_metrics([:bounce_rate], query) == {[], [:bounce_rate], []}+ assert partition_metrics([:bounce_rate], query) == [sessions: [:bounce_rate]]endtest "session filters but no session metrics" doquery = make_query(["visit:source"])- assert partition_metrics([:total_revenue], query) == {[:total_revenue], [], []}+ assert partition_metrics([:total_revenue], query) == [events: [:total_revenue]]endtest "sample_percent is added to both types of metrics" doquery = make_query([])- assert partition_metrics([:total_revenue, :sample_percent], query) ==- {[:total_revenue, :sample_percent], [], []}+ assert partition_metrics([:total_revenue, :sample_percent], query) == [+ events: [:total_revenue, :sample_percent]+ ]- assert partition_metrics([:bounce_rate, :sample_percent], query) ==- {[], [:bounce_rate, :sample_percent], []}+ assert partition_metrics([:bounce_rate, :sample_percent], query) == [+ sessions: [:bounce_rate, :sample_percent]+ ]- assert partition_metrics([:total_revenue, :bounce_rate, :sample_percent], query) ==- {[:total_revenue, :sample_percent], [:bounce_rate, :sample_percent], []}+ assert partition_metrics([:total_revenue, :bounce_rate, :sample_percent], query) == [+ events: [:total_revenue, :sample_percent],+ sessions: [:bounce_rate, :sample_percent]+ ]end- test "other metrics put in its own result" do+ test "other metrics get ignored" doquery = make_query([])- assert partition_metrics([:percentage, :total_visitors], query) ==- {[], [:percentage], [:total_visitors]}+ assert partition_metrics([:percentage, :total_visitors], query) == [sessions: [:percentage]]endtest "metrics that can be calculated on either when event-only metrics" doquery = make_query([])- assert partition_metrics([:total_revenue, :visitors], query) ==- {[:total_revenue, :visitors], [], []}+ assert partition_metrics([:total_revenue, :visitors], query) == [+ events: [:total_revenue, :visitors]+ ]- assert partition_metrics([:pageviews, :visits], query) == {[:pageviews, :visits], [], []}+ assert partition_metrics([:pageviews, :visits], query) == [events: [:pageviews, :visits]]endtest "metrics that can be calculated on either when session-only metrics" doquery = make_query([])- assert partition_metrics([:bounce_rate, :visitors], query) ==- {[], [:bounce_rate, :visitors], []}+ assert partition_metrics([:bounce_rate, :visitors], query) == [+ sessions: [:bounce_rate, :visitors]+ ]- assert partition_metrics([:visit_duration, :visits], query) ==- {[], [:visit_duration, :visits], []}+ assert partition_metrics([:visit_duration, :visits], query) == [+ sessions: [:visit_duration, :visits]+ ]endtest "metrics that can be calculated on either are biased to events" doquery = make_query([])- assert partition_metrics([:bounce_rate, :total_revenue, :visitors], query) ==- {[:total_revenue, :visitors], [:bounce_rate], []}+ assert partition_metrics([:bounce_rate, :total_revenue, :visitors], query) == [+ events: [:total_revenue, :visitors],+ sessions: [:bounce_rate]+ ]endtest "sample_percent is handled with either metrics" doquery = make_query([])- assert partition_metrics([:visitors, :sample_percent], query) ==- {[], [:visitors, :sample_percent], []}+ assert partition_metrics([:visitors, :sample_percent], query) == [+ sessions: [:visitors, :sample_percent]+ ]endtest "metric can be calculated on either, but filtering on events" doquery = make_query(["event:name"])- assert partition_metrics([:visitors], query) == {[:visitors], [], []}+ assert partition_metrics([:visitors], query) == [events: [:visitors]]endtest "metric can be calculated on either, but filtering on events and sessions" doquery = make_query(["event:name", "visit:exit_page"])- assert partition_metrics([:visitors], query) == {[], [:visitors], []}+ assert partition_metrics([:visitors], query) == [sessions: [:visitors]]endtest "metric can be calculated on either, filtering on either" doquery = make_query(["visit:source"])- assert partition_metrics([:visitors], query) == {[], [:visitors], []}+ assert partition_metrics([:visitors], query) == [sessions: [:visitors]]endtest "metric can be calculated on either, filtering on sessions" doquery = make_query(["visit:exit_page"])- assert partition_metrics([:visitors], query) == {[], [:visitors], []}+ assert partition_metrics([:visitors], query) == [sessions: [:visitors]]endtest "query dimensions lean metric" do- assert partition_metrics([:visitors], make_query([], ["event:name"])) ==- {[:visitors], [], []}-- assert partition_metrics([:visitors], make_query([], ["visit:source"])) ==- {[], [:visitors], []}-- assert partition_metrics([:visitors], make_query([], ["visit:exit_page"])) ==- {[], [:visitors], []}+ assert partition_metrics([:visitors], make_query([], ["event:name"])) == [+ events: [:visitors]+ ]++ assert partition_metrics([:visitors], make_query([], ["visit:source"])) == [+ sessions: [:visitors]+ ]++ assert partition_metrics([:visitors], make_query([], ["visit:exit_page"])) == [+ sessions: [:visitors]+ ]+ end++ test "smearable metrics" do+ assert partition_metrics(+ [:visitors, :visits, :visit_duration, :pageviews],+ make_query([], ["time:minute"])+ ) == [+ events: [:pageviews],+ sessions: [:visit_duration],+ sessions_smeared: [:visitors, :visits]+ ]++ assert partition_metrics([:visitors], make_query([], ["time:hour"])) == [+ sessions_smeared: [:visitors]+ ]++ assert partition_metrics([:visitors], make_query([], ["time:day"])) == [+ sessions: [:visitors]+ ]++ assert partition_metrics([:visitors], make_query([], [])) == [+ sessions: [:visitors]+ ]endenddiff --git a/test/plausible_web/controllers/api/external_stats_controller/query_test.exs b/test/plausible_web/controllers/api/external_stats_controller/query_test.exsindex 310e42e290..2f22cef28c 100644--- a/test/plausible_web/controllers/api/external_stats_controller/query_test.exs+++ b/test/plausible_web/controllers/api/external_stats_controller/query_test.exs@@ -1681,6 +1681,76 @@ defmodule PlausibleWeb.Api.ExternalStatsController.QueryTest do%{"dimensions" => ["2021-01-02 12:00:00"], "metrics" => [2]}]end++ test "visitors and visits are smeared across time:minute buckets but visit_duration is not",+ %{conn: conn, site: site} do+ populate_stats(site, [+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 00:00:00]),+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 00:10:00]),+ build(:pageview, user_id: 2, timestamp: ~N[2021-01-01 00:05:00]),+ build(:pageview, user_id: 2, timestamp: ~N[2021-01-01 00:08:00])+ ])++ conn =+ post(conn, "/api/v2/query-internal-test", %{+ "site_id" => site.domain,+ "metrics" => ["visitors", "visits", "visit_duration", "pageviews"],+ "date_range" => ["2021-01-01T00:00:00Z", "2021-01-01T00:30:00Z"],+ "dimensions" => ["time:minute"]+ })++ assert json_response(conn, 200)["results"] == [+ %{"dimensions" => ["2021-01-01 00:00:00"], "metrics" => [1, 1, 0, 1]},+ %{"dimensions" => ["2021-01-01 00:01:00"], "metrics" => [1, 1, 0, 0]},+ %{"dimensions" => ["2021-01-01 00:02:00"], "metrics" => [1, 1, 0, 0]},+ %{"dimensions" => ["2021-01-01 00:03:00"], "metrics" => [1, 1, 0, 0]},+ %{"dimensions" => ["2021-01-01 00:04:00"], "metrics" => [1, 1, 0, 0]},+ %{"dimensions" => ["2021-01-01 00:05:00"], "metrics" => [2, 2, 0, 1]},+ %{"dimensions" => ["2021-01-01 00:06:00"], "metrics" => [2, 2, 0, 0]},+ %{"dimensions" => ["2021-01-01 00:07:00"], "metrics" => [2, 2, 0, 0]},+ %{"dimensions" => ["2021-01-01 00:08:00"], "metrics" => [2, 2, 180, 1]},+ %{"dimensions" => ["2021-01-01 00:09:00"], "metrics" => [1, 1, 0, 0]},+ %{"dimensions" => ["2021-01-01 00:10:00"], "metrics" => [1, 1, 600, 1]}+ ]+ end++ test "visitors and visits are smeared across time:hour buckets but visit_duration is not", %{+ conn: conn,+ site: site+ } do+ populate_stats(site, [+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 00:00:00]),+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 00:20:00]),+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 00:40:00]),+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 01:00:00]),+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 01:20:00]),+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 01:40:00]),+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 02:00:00]),+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 02:20:00]),+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 02:40:00]),+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 03:00:00]),+ build(:pageview, user_id: 1, timestamp: ~N[2021-01-01 03:20:00]),+ build(:pageview, user_id: 2, timestamp: ~N[2021-01-01 01:05:00]),+ build(:pageview, user_id: 2, timestamp: ~N[2021-01-01 01:10:00]),+ build(:pageview, user_id: 3, timestamp: ~N[2021-01-01 02:10:00]),+ build(:pageview, user_id: 3, timestamp: ~N[2021-01-01 02:20:00])+ ])++ conn =+ post(conn, "/api/v2/query", %{+ "site_id" => site.domain,+ "metrics" => ["visits", "visitors", "visit_duration", "pageviews"],+ "date_range" => ["2021-01-01", "2021-01-01"],+ "dimensions" => ["time:hour"]+ })++ assert json_response(conn, 200)["results"] == [+ %{"dimensions" => ["2021-01-01 00:00:00"], "metrics" => [1, 1, 0, 3]},+ %{"dimensions" => ["2021-01-01 01:00:00"], "metrics" => [2, 2, 300, 5]},+ %{"dimensions" => ["2021-01-01 02:00:00"], "metrics" => [2, 2, 600, 5]},+ %{"dimensions" => ["2021-01-01 03:00:00"], "metrics" => [1, 1, 12_000, 2]}+ ]+ endendtest "breakdown by visit:source", %{conn: conn, site: site} do