Compare commits

...

9 Commits

@ -29,8 +29,7 @@ if (container) {
embedded: container.dataset.embedded,
background: container.dataset.background,
isDbip: container.dataset.isDbip === 'true',
flags: JSON.parse(container.dataset.flags),
validIntervalsByPeriod: JSON.parse(container.dataset.validIntervalsByPeriod)
flags: JSON.parse(container.dataset.flags)
}
const loggedIn = container.dataset.loggedIn === 'true'

@ -1,42 +1,4 @@
import numberFormatter, {durationFormatter} from '../../util/number-formatter'
import { parsePrefix } from '../../util/filters'
export function getGraphableMetrics(query, site) {
const isRealtime = query.period === 'realtime'
const goalFilter = query.filters.goal
const pageFilter = query.filters.page
if (isRealtime && goalFilter) {
return ["visitors"]
} else if (isRealtime) {
return ["visitors", "pageviews"]
} else if (goalFilter && canGraphRevenueMetrics(goalFilter, site)) {
return ["visitors", "events", "average_revenue", "total_revenue", "conversion_rate"]
} else if (goalFilter) {
return ["visitors", "events", "conversion_rate"]
} else if (pageFilter) {
return ["visitors", "visits", "pageviews", "bounce_rate", "time_on_page"]
} else {
return ["visitors", "visits", "pageviews", "views_per_visit", "bounce_rate", "visit_duration"]
}
}
// Revenue metrics can only be graphed if:
// * The query is filtered by at least one revenue goal
// * All revenue goals in filter have the same currency
function canGraphRevenueMetrics(goalFilter, site) {
const goalsInFilter = parsePrefix(goalFilter).values
const revenueGoalsInFilter = site.revenueGoals.filter((rg) => {
return goalsInFilter.includes(rg.event_name)
})
const singleCurrency = revenueGoalsInFilter.every((rg) => {
return rg.currency === revenueGoalsInFilter[0].currency
})
return revenueGoalsInFilter.length > 0 && singleCurrency
}
export const METRIC_LABELS = {
'visitors': 'Visitors',

@ -2,9 +2,7 @@ import { Menu, Transition } from '@headlessui/react';
import { ChevronDownIcon } from '@heroicons/react/20/solid'
import React, { Fragment, useCallback, useEffect } from 'react';
import classNames from 'classnames'
import * as storage from '../../util/storage'
import { isKeyPressed } from '../../keybinding.js'
import { monthsBetweenDates } from '../../util/date.js'
const INTERVAL_LABELS = {
'minute': 'Minutes',
@ -14,22 +12,6 @@ const INTERVAL_LABELS = {
'month': 'Months'
}
function validIntervals(site, query) {
if (query.period === "custom" && monthsBetweenDates(query.from, query.to) > 12) {
return ["week", "month"]
} else {
return site.validIntervalsByPeriod[query.period]
}
}
function getStoredInterval(period, domain) {
return storage.getItem(`interval__${period}__${domain}`)
}
function storeInterval(period, domain, interval) {
storage.setItem(`interval__${period}__${domain}`, interval)
}
function subscribeKeybinding(element) {
const handleKeyPress = useCallback((event) => {
if (isKeyPressed(event, "i")) element.current?.click()
@ -41,41 +23,21 @@ function subscribeKeybinding(element) {
}, [handleKeyPress])
}
export const getCurrentInterval = function(site, query) {
const options = validIntervals(site, query)
const storedInterval = getStoredInterval(query.period, site.domain)
const defaultInterval = [...options].pop()
if (storedInterval && options.includes(storedInterval)) {
return storedInterval
} else {
return defaultInterval
}
}
export function IntervalPicker({ query, site, onIntervalUpdate }) {
export function IntervalPicker({ query, currentInterval, options, onIntervalUpdate }) {
if (query.period == 'realtime') return null
const menuElement = React.useRef(null)
const options = validIntervals(site, query)
const currentInterval = getCurrentInterval(site, query)
subscribeKeybinding(menuElement)
function updateInterval(interval) {
storeInterval(query.period, site.domain, interval)
onIntervalUpdate(interval)
}
function renderDropdownItem(option) {
return (
<Menu.Item onClick={() => updateInterval(option)} key={option} disabled={option == currentInterval}>
<Menu.Item onClick={() => onIntervalUpdate(option)} key={option} disabled={option == currentInterval}>
{({ active }) => (
<span className={classNames({
'bg-gray-100 dark:bg-gray-900 text-gray-900 dark:text-gray-200 cursor-pointer': active,
'text-gray-700 dark:text-gray-200': !active,
'font-bold cursor-none select-none': option == currentInterval,
'font-bold select-none': option == currentInterval,
}, 'block px-4 py-2 text-sm')}>
{INTERVAL_LABELS[option]}
</span>

@ -1,8 +1,7 @@
import React, { useState } from "react"
import * as api from '../../api'
import { getCurrentInterval } from "./interval-picker"
export default function StatsExport({site, query}) {
export default function StatsExport({site, query}) {
const [exporting, setExporting] = useState(false)
function startExport() {
@ -29,7 +28,8 @@ export default function StatsExport({site, query}) {
}
function renderExportLink() {
const interval = getCurrentInterval(site, query)
// FIXME const interval = getCurrentInterval(site, query)
const interval = 'day'
const queryParams = api.serializeQuery(query, [{ interval }])
const endpoint = `/${encodeURIComponent(site.domain)}/export${queryParams}`
@ -50,4 +50,4 @@ export default function StatsExport({site, query}) {
{!exporting && renderExportLink()}
</div>
)
}
}

@ -5,7 +5,6 @@ import classNames from "classnames";
import numberFormatter, { durationFormatter } from '../../util/number-formatter'
import * as storage from '../../util/storage'
import { formatDateRange } from '../../util/date.js'
import { getGraphableMetrics } from "./graph-util.js";
function Maybe({condition, children}) {
if (condition) {
@ -88,18 +87,6 @@ export default function TopStats(props) {
)
}
function canMetricBeGraphed(stat) {
const graphableMetrics = getGraphableMetrics(query, site)
return stat.graph_metric && graphableMetrics.includes(stat.graph_metric)
}
function maybeUpdateMetric(stat) {
if (canMetricBeGraphed(stat)) {
storage.setItem(`metric__${site.domain}`, stat.graph_metric)
onMetricUpdate(stat.graph_metric)
}
}
function blinkingDot() {
return (
<div key="dot" className="block pulsating-circle" style={{ left: '125px', top: '52px' }}></div>
@ -130,13 +117,13 @@ export default function TopStats(props) {
function renderStat(stat, index) {
const className = classNames('px-4 md:px-6 w-1/2 my-4 lg:w-auto group select-none', {
'cursor-pointer': canMetricBeGraphed(stat),
'cursor-pointer': stat.graph_metric,
'lg:border-l border-gray-300': index > 0,
'border-r lg:border-r-0': index % 2 === 0
})
return (
<Tooltip key={stat.name} info={tooltip(stat, query)} className={className} onClick={() => { maybeUpdateMetric(stat) }} boundary={tooltipBoundary}>
<Tooltip key={stat.name} info={tooltip(stat, query)} className={className} onClick={() => { onMetricUpdate(stat.graph_metric) }} boundary={tooltipBoundary}>
{renderStatName(stat)}
<div className="my-1 space-y-2">
<div>

@ -1,30 +1,19 @@
import React, { useState, useEffect, useRef, useCallback } from 'react';
import * as api from '../../api'
import * as storage from '../../util/storage'
import { getGraphableMetrics } from './graph-util'
import TopStats from './top-stats';
import { IntervalPicker, getCurrentInterval } from './interval-picker'
import { IntervalPicker } from './interval-picker'
import StatsExport from './stats-export'
import WithImportedSwitch from './with-imported-switch';
import SamplingNotice from './sampling-notice';
import FadeIn from '../../fade-in';
import * as url from '../../util/url'
import { isComparisonEnabled } from '../../comparison-input'
import LineGraphWithRouter from './line-graph'
function fetchTopStats(site, query) {
const q = { ...query }
if (!isComparisonEnabled(q.comparison)) {
q.comparison = 'previous_period'
}
return api.get(url.apiPath(site, '/top-stats'), q)
}
function fetchMainGraph(site, query, metric, interval) {
const params = {metric, interval}
return api.get(url.apiPath(site, '/main-graph'), query, params)
const LoadingState = {
LOADING: 'loading',
UPDATING_GRAPH: 'updatingGraph',
READY: 'ready'
}
export default function VisitorGraph(props) {
@ -35,34 +24,27 @@ export default function VisitorGraph(props) {
const topStatsBoundary = useRef(null)
const [topStatData, setTopStatData] = useState(null)
const [topStatsLoading, setTopStatsLoading] = useState(true)
const [graphData, setGraphData] = useState(null)
const [graphLoading, setGraphLoading] = useState(true)
// This state is explicitly meant for the situation where either graph interval
// or graph metric is changed. That results in behaviour where Top Stats stay
// intact, but the graph container alone will display a loading spinner for as
// long as new graph data is fetched.
const [graphRefreshing, setGraphRefreshing] = useState(false)
const [loadingState, setLoadingState] = useState(LoadingState.LOADING)
const onIntervalUpdate = useCallback((newInterval) => {
storage.setInterval(site, query, newInterval)
setGraphData(null)
setGraphRefreshing(true)
fetchGraphData(getStoredMetric(), newInterval)
setLoadingState(LoadingState.UPDATING_GRAPH)
fetchGraphData(storage.getMetric(site), newInterval)
}, [query])
const onMetricUpdate = useCallback((newMetric) => {
storage.setMetric(site, newMetric)
setGraphData(null)
setGraphRefreshing(true)
fetchGraphData(newMetric, getCurrentInterval(site, query))
setLoadingState(LoadingState.UPDATING_GRAPH)
fetchGraphData(newMetric, storage.getInterval(site, query))
}, [query])
useEffect(() => {
setTopStatData(null)
setTopStatsLoading(true)
setGraphData(null)
setGraphLoading(true)
setLoadingState(LoadingState.LOADING)
fetchTopStatsAndGraphData()
if (isRealtime) {
@ -79,38 +61,27 @@ export default function VisitorGraph(props) {
}, [topStatData])
function fetchTopStatsAndGraphData() {
fetchTopStats(site, query)
const metric = storage.getMetric(site)
const interval = storage.getInterval(site, query)
api.get(url.apiPath(site, '/top-report'), query, {metric, interval})
.then((res) => {
storage.setInterval(site, query, res.interval)
storage.setMetric(site, res.metric)
setTopStatData(res)
setTopStatsLoading(false)
setGraphData(res)
setLoadingState(LoadingState.READY)
})
let metric = getStoredMetric()
const availableMetrics = getGraphableMetrics(query, site)
if (!availableMetrics.includes(metric)) {
metric = availableMetrics[0]
storage.setItem(`metric__${site.domain}`, metric)
}
const interval = getCurrentInterval(site, query)
fetchGraphData(metric, interval)
}
function fetchGraphData(metric, interval) {
fetchMainGraph(site, query, metric, interval)
api.get(url.apiPath(site, '/main-graph'), query, {metric, interval})
.then((res) => {
setGraphData(res)
setGraphLoading(false)
setGraphRefreshing(false)
setLoadingState(LoadingState.READY)
})
}
function getStoredMetric() {
return storage.getItem(`metric__${site.domain}`)
}
function storeTopStatsContainerHeight() {
storage.setItem(`topStatsHeight__${site.domain}`, document.getElementById('top-stats-container').clientHeight)
}
@ -130,18 +101,18 @@ export default function VisitorGraph(props) {
return (
<div className={"relative w-full mt-2 bg-white rounded shadow-xl dark:bg-gray-825"}>
{(topStatsLoading || graphLoading) && renderLoader()}
<FadeIn show={!(topStatsLoading || graphLoading)}>
{loadingState == LoadingState.LOADING && renderLoader()}
<FadeIn show={loadingState !== LoadingState.LOADING}>
<div id="top-stats-container" className="flex flex-wrap" ref={topStatsBoundary} style={{ height: getTopStatsHeight() }}>
<TopStats site={site} query={query} data={topStatData} onMetricUpdate={onMetricUpdate} tooltipBoundary={topStatsBoundary.current} lastLoadTimestamp={lastLoadTimestamp} />
</div>
<div className="relative px-2">
{graphRefreshing && renderLoader()}
{loadingState === LoadingState.UPDATING_GRAPH && renderLoader()}
<div className="absolute right-4 -top-8 py-1 flex items-center">
{!isRealtime && <StatsExport site={site} query={query} />}
<SamplingNotice samplePercent={topStatData}/>
<WithImportedSwitch site={site} topStatData={topStatData} />
<IntervalPicker site={site} query={query} onIntervalUpdate={onIntervalUpdate} />
<IntervalPicker query={query} currentInterval={storage.getInterval(site, query)} options={topStatData?.valid_intervals || []} onIntervalUpdate={onIntervalUpdate} />
</div>
<LineGraphWithRouter graphData={graphData} darkTheme={isDarkTheme} query={query} />
</div>

@ -124,8 +124,3 @@ export function isAfter(date1, date2, period) {
}
return date1.date() > date2.date()
}
export function monthsBetweenDates(date1, date2) {
var diffMonths = (date2.year() - date1.year()) * 12 + date2.month() - date1.month();
return Math.abs(diffMonths);
}

@ -33,3 +33,19 @@ export function getItem(key) {
return memStore[key]
}
}
export function setInterval(site, query, interval) {
setItem(`interval__${query.period}__${site.domain}`, interval)
}
export function getInterval(site, query) {
return getItem(`interval__${query.period}__${site.domain}`)
}
export function setMetric(site, metric) {
setItem(`metric__${site.domain}`, metric)
}
export function getMetric(site) {
return getItem(`metric__${site.domain}`)
}

@ -24,4 +24,8 @@ defmodule Plausible.Stats.Metrics do
def from_string!(str) do
Map.fetch!(@metric_mappings, str)
end
def from_string(str, default) do
Map.get(@metric_mappings, str, default)
end
end

@ -96,6 +96,74 @@ defmodule PlausibleWeb.Api.StatsController do
```
"""
def top_report(conn, params) do
site = conn.assigns[:site]
with {:ok, dates} <- parse_date_params(params) do
valid_intervals = Plausible.Stats.Interval.valid_by_period(site: site)[params["period"]]
params =
if params["interval"] in valid_intervals do
params
else
Map.delete(params, "interval")
end
query = Query.from(site, params)
timeseries_query =
if query.period == "realtime" do
%Query{query | period: "30m"}
else
query
end
comparison_opts = parse_comparison_opts(params)
comparison_query =
case Comparisons.compare(site, query, params["comparison"], comparison_opts) do
{:ok, comparison_query} -> comparison_query
{:error, :not_supported} -> nil
end
{top_stats, sample_percent} = fetch_top_stats(site, query, comparison_query)
metric = resolve_metric(top_stats, params)
timeseries_result = Stats.timeseries(site, timeseries_query, [metric])
comparison_result =
if comparison_query, do: Stats.timeseries(site, comparison_query, [metric])
labels = label_timeseries(timeseries_result, comparison_result)
present_index = present_index_for(site, query, labels)
full_intervals = build_full_intervals(query, labels)
valid_intervals = Plausible.Stats.Interval.valid_by_period(site: site)[query.period]
json(conn, %{
metric: metric,
plot: plot_timeseries(timeseries_result, metric),
labels: labels,
comparison_plot: comparison_result && plot_timeseries(comparison_result, metric),
comparison_labels: comparison_result && label_timeseries(comparison_result, nil),
comparing_from: comparison_result && comparison_query.date_range.first,
comparing_to: comparison_result && comparison_query.date_range.last,
present_index: present_index,
interval: query.interval,
with_imported: with_imported?(query, comparison_query),
imports_exist: site.complete_import_ids != [],
full_intervals: full_intervals,
from: query.date_range.first,
to: query.date_range.last,
valid_intervals: valid_intervals,
top_stats: top_stats,
sample_percent: sample_percent
})
else
{:error, message} when is_binary(message) -> bad_request(conn, message)
end
end
def main_graph(conn, params) do
site = conn.assigns[:site]
@ -103,7 +171,7 @@ defmodule PlausibleWeb.Api.StatsController do
:ok <- validate_interval(params),
:ok <- validate_interval_granularity(site, params, dates),
query = Query.from(site, params),
{:ok, metric} <- parse_and_validate_graph_metric(params, query) do
metric <- Plausible.Stats.Metrics.from_string(params["metric"], :visitors) do
timeseries_query =
if query.period == "realtime" do
%Query{query | period: "30m"}
@ -136,8 +204,6 @@ defmodule PlausibleWeb.Api.StatsController do
comparison_labels: comparison_result && label_timeseries(comparison_result, nil),
present_index: present_index,
interval: query.interval,
with_imported: with_imported?(query, comparison_query),
imports_exist: site.complete_import_ids != [],
full_intervals: full_intervals
})
else
@ -1356,23 +1422,6 @@ defmodule PlausibleWeb.Api.StatsController do
end
end
defp parse_and_validate_graph_metric(params, query) do
metric =
case params["metric"] do
nil -> :visitors
"conversions" -> :visitors
m -> Plausible.Stats.Metrics.from_string!(m)
end
requires_goal_filter? = metric in [:conversion_rate, :events]
if requires_goal_filter? and !query.filters["event:goal"] do
{:error, "Metric `#{metric}` can only be queried with a goal filter"}
else
{:ok, metric}
end
end
defp bad_request(conn, message, extra \\ %{}) do
payload = Map.merge(extra, %{error: message})
@ -1382,6 +1431,21 @@ defmodule PlausibleWeb.Api.StatsController do
|> halt()
end
defp resolve_metric(top_stats, params) do
available_metrics =
top_stats
|> Enum.map(& &1[:graph_metric])
|> Enum.reject(&is_nil/1)
requested_metric = Plausible.Stats.Metrics.from_string(params["metric"], :visitors)
if requested_metric in available_metrics do
requested_metric
else
List.first(available_metrics)
end
end
defp parse_comparison_opts(params) do
[
from: params["compare_from"],

@ -135,6 +135,7 @@ defmodule PlausibleWeb.Router do
get "/:domain/current-visitors", StatsController, :current_visitors
get "/:domain/main-graph", StatsController, :main_graph
get "/:domain/top-report", StatsController, :top_report
get "/:domain/top-stats", StatsController, :top_stats
get "/:domain/sources", StatsController, :sources
get "/:domain/utm_mediums", StatsController, :utm_mediums

@ -39,9 +39,6 @@
data-is-dbip={to_string(@is_dbip)}
data-current-user-role={@conn.assigns[:current_user_role]}
data-flags={Jason.encode!(@flags)}
data-valid-intervals-by-period={
Plausible.Stats.Interval.valid_by_period(site: @site) |> Jason.encode!()
}
>
</div>
<div id="modal_root"></div>

@ -436,20 +436,6 @@ defmodule PlausibleWeb.Api.StatsController.MainGraphTest do
describe "GET /api/stats/main-graph - conversion_rate plot" do
setup [:create_user, :log_in, :create_new_site]
test "returns 400 when conversion rate is queried without a goal filter", %{
conn: conn,
site: site
} do
conn =
get(
conn,
"/api/stats/#{site.domain}/main-graph?period=month&date=2021-01-01&metric=conversion_rate"
)
assert %{"error" => error} = json_response(conn, 400)
assert error =~ "can only be queried with a goal filter"
end
test "displays conversion_rate for a month", %{conn: conn, site: site} do
insert(:goal, site: site, event_name: "Signup")
@ -481,20 +467,6 @@ defmodule PlausibleWeb.Api.StatsController.MainGraphTest do
describe "GET /api/stats/main-graph - events (total conversions) plot" do
setup [:create_user, :log_in, :create_new_site]
test "returns 400 when the `events` metric is queried without a goal filter", %{
conn: conn,
site: site
} do
conn =
get(
conn,
"/api/stats/#{site.domain}/main-graph?period=month&date=2021-01-01&metric=events"
)
assert %{"error" => error} = json_response(conn, 400)
assert error =~ "`events` can only be queried with a goal filter"
end
test "displays total conversions for a goal", %{conn: conn, site: site} do
insert(:goal, site: site, event_name: "Signup")

@ -0,0 +1,45 @@
defmodule PlausibleWeb.Api.StatsController.TopReportTest do
use PlausibleWeb.ConnCase
@user_id 123
describe "GET /api/stats/top-report" do
setup [:create_user, :log_in, :create_new_site]
test "returns graph and top stats", %{conn: conn, site: site} do
populate_stats(site, [
build(:pageview, timestamp: ~N[2021-01-11 04:00:00]),
build(:pageview, timestamp: ~N[2021-01-11 05:00:00]),
build(:pageview, timestamp: ~N[2021-01-11 18:00:00])
])
conn =
get(
conn,
"/api/stats/#{site.domain}/top-report?period=day&date=2021-01-11&metric=pageviews"
)
assert %{"plot" => curr, "top_stats" => top_stats} = json_response(conn, 200)
assert [0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0] = curr
assert %{
"name" => "Unique visitors",
"value" => 3,
"graph_metric" => "visitors"
} in top_stats
end
test "always adds comparison for top stats"
test "compares both top stats and graph when requested"
test "overrides metric with default when invalid metric provided", %{site: site, conn: conn} do
# requires goal filter
conn = get(conn, "/api/stats/#{site.domain}/top-report?period=day&metric=events")
assert %{"metric" => "visitors"} = json_response(conn, 200)
end
test "overrides interval with default when invalid interval provided"
test "custom date range interval handling"
test "all time date range interval handling"
end
end
Loading…
Cancel
Save