Upload folder using huggingface_hub (part 4)

lib/plausible_web.ex

@@ -0,0 +1,152 @@
+defmodule PlausibleWeb do
+  @moduledoc false
+
+  use Plausible
+
+  def live_view(opts \\ []) do
+    quote do
+      use Plausible
+      use Phoenix.LiveView, global_prefixes: ~w(x-)
+      use PlausibleWeb.Live.Flash
+
+      use PlausibleWeb.Live.AuthContext
+
+      unless :no_sentry_context in unquote(opts) do
+        use PlausibleWeb.Live.SentryContext
+      end
+
+      on_ee do
+        use Plausible.Audit.LiveContext
+      end
+
+      alias PlausibleWeb.Router.Helpers, as: Routes
+      alias Phoenix.LiveView.JS
+
+      import PlausibleWeb.Components.Generic
+      import PlausibleWeb.Live.Components.Form
+    end
+  end
+
+  def live_component do
+    quote do
+      use Phoenix.LiveComponent, global_prefixes: ~w(x-)
+      import PlausibleWeb.Components.Generic
+      import PlausibleWeb.Live.Components.Form
+      alias Phoenix.LiveView.JS
+      alias PlausibleWeb.Router.Helpers, as: Routes
+    end
+  end
+
+  def component do
+    quote do
+      use Phoenix.Component, global_prefixes: ~w(x-)
+      import PlausibleWeb.Components.Generic
+      import PlausibleWeb.Live.Components.Form
+      alias Phoenix.LiveView.JS
+      alias PlausibleWeb.Router.Helpers, as: Routes
+    end
+  end
+
+  def controller do
+    quote do
+      use Phoenix.Controller, formats: [html: "View", json: "View"]
+
+      import Plug.Conn
+      import PlausibleWeb.ControllerHelpers
+      alias PlausibleWeb.Router.Helpers, as: Routes
+    end
+  end
+
+  def view do
+    quote do
+      use Phoenix.View,
+        root: "lib/plausible_web/templates"
+
+      # Import convenience functions from controllers
+      import Phoenix.Controller, only: [view_module: 1]
+
+      use Phoenix.Component, global_prefixes: ~w(x-)
+
+      import PlausibleWeb.Components.Generic
+      import PlausibleWeb.Live.Components.Form
+      alias PlausibleWeb.Router.Helpers, as: Routes
+    end
+  end
+
+  on_ee do
+    def extra_view do
+      quote do
+        use Phoenix.View,
+          root: "extra/lib/plausible_web/templates"
+
+        # Import convenience functions from controllers
+        import Phoenix.Controller, only: [view_module: 1]
+
+        use Phoenix.Component
+
+        import PlausibleWeb.Components.Generic
+        import PlausibleWeb.Live.Components.Form
+        alias PlausibleWeb.Router.Helpers, as: Routes
+      end
+    end
+  end
+
+  def router do
+    quote do
+      use Phoenix.Router
+      import Plug.Conn
+      import Phoenix.Controller
+    end
+  end
+
+  def channel do
+    quote do
+      use Phoenix.Channel
+    end
+  end
+
+  def plugins_api_controller do
+    quote do
+      use Phoenix.Controller, formats: [:json]
+      import Plug.Conn
+      import PlausibleWeb.Router.Helpers
+
+      alias PlausibleWeb.Plugins.API.Schemas
+      alias PlausibleWeb.Plugins.API.Views
+      alias PlausibleWeb.Plugins.API.Errors
+      alias Plausible.Plugins.API
+
+      plug(OpenApiSpex.Plug.CastAndValidate, json_render_error_v2: true, replace_params: false)
+
+      use OpenApiSpex.ControllerSpecs
+    end
+  end
+
+  def plugins_api_view do
+    quote do
+      use Phoenix.View, root: ""
+
+      alias PlausibleWeb.Router.Helpers
+      import PlausibleWeb.Plugins.API.Views.Pagination, only: [render_metadata_links: 4]
+    end
+  end
+
+  def open_api_schema do
+    quote do
+      require OpenApiSpex
+      alias OpenApiSpex.Schema
+      alias PlausibleWeb.Plugins.API.Schemas
+    end
+  end
+
+  @doc """
+  When used, dispatch to the appropriate controller/view/etc.
+  """
+  defmacro __using__(which) when is_atom(which) do
+    apply(__MODULE__, which, [])
+  end
+
+  defmacro __using__([{which, opts}]) when is_atom(which) do
+    apply(__MODULE__, which, [List.wrap(opts)])
+  end
+end

lib/plausible_web/views/stats_view.ex

@@ -0,0 +1,80 @@
+defmodule PlausibleWeb.StatsView do
+  use PlausibleWeb, :view
+  use Plausible
+
+  require Plausible.Billing
+
+  def plausible_url do
+    PlausibleWeb.Endpoint.url()
+  end
+
+  def large_number_format(n, opts \\ []) do
+    k = if Keyword.get(opts, :capitalize_k?, false), do: "K", else: "k"
+
+    cond do
+      n >= 1_000 && n < 1_000_000 ->
+        thousands = trunc(n / 100) / 10
+
+        if thousands == trunc(thousands) || n >= 100_000 do
+          "#{trunc(thousands)}" <> k
+        else
+          "#{thousands}" <> k
+        end
+
+      n >= 1_000_000 && n < 1_000_000_000 ->
+        millions = trunc(n / 100_000) / 10
+
+        if millions == trunc(millions) || n > 100_000_000 do
+          "#{trunc(millions)}M"
+        else
+          "#{millions}M"
+        end
+
+      n >= 1_000_000_000 && n < 1_000_000_000_000 ->
+        billions = trunc(n / 100_000_000) / 10
+
+        if billions == trunc(billions) || n > 100_000_000_000 do
+          "#{trunc(billions)}B"
+        else
+          "#{billions}B"
+        end
+
+      is_integer(n) ->
+        Integer.to_string(n)
+    end
+  end
+
+  def stats_container_class(conn) do
+    cond do
+      conn.assigns[:embedded] && conn.params["width"] == "manual" -> "px-6"
+      conn.assigns[:embedded] -> "max-w-screen-xl mx-auto px-6"
+      !conn.assigns[:embedded] -> "container print:max-w-full"
+    end
+  end
+
+  @doc """
+  Returns a readable stats URL.
+
+  Native Phoenix router functions percent-encode all diacritics, resulting in
+  ugly URLs, e.g. `https://plausible.io/café.com` transforms into
+  `https://plausible.io/caf%C3%A9.com`.
+
+  This function encodes only the slash (`/`) character from the site's domain.
+
+  ## Examples
+
+     iex> PlausibleWeb.StatsView.pretty_stats_url(%Plausible.Site{domain: "user.gittea.io/repo"})
+     "http://localhost:8000/user.gittea.io%2Frepo"
+
+     iex> PlausibleWeb.StatsView.pretty_stats_url(%Plausible.Site{domain: "anakin.test"})
+     "http://localhost:8000/anakin.test"
+
+     iex> PlausibleWeb.StatsView.pretty_stats_url(%Plausible.Site{domain: "café.test"})
+     "http://localhost:8000/café.test"
+
+  """
+  def pretty_stats_url(%Plausible.Site{domain: domain}) when is_binary(domain) do
+    pretty_domain = String.replace(domain, "/", "%2F")
+    "#{plausible_url()}/#{pretty_domain}"
+  end
+end

lib/plausible_web/views/text_helpers.ex

@@ -0,0 +1,53 @@
+defmodule PlausibleWeb.TextHelpers do
+  @moduledoc false
+
+  @spec pretty_join([String.t()]) :: String.t()
+
+  @doc """
+  Turns a list of strings into a string and replaces the last comma
+  with the word "and".
+
+  ### Examples:
+
+      iex> ["one"] |> PlausibleWeb.TextHelpers.pretty_join()
+      "one"
+
+      iex> ["one", "two"] |> PlausibleWeb.TextHelpers.pretty_join()
+      "one and two"
+
+      iex> ["one", "two", "three"] |> PlausibleWeb.TextHelpers.pretty_join()
+      "one, two and three"
+  """
+  def pretty_join([str]), do: str
+
+  def pretty_join(list) do
+    [last_string | rest] = Enum.reverse(list)
+
+    rest_string =
+      rest
+      |> Enum.reverse()
+      |> Enum.join(", ")
+
+    "#{rest_string} and #{last_string}"
+  end
+
+  def pretty_list(list) do
+    list
+    |> Enum.map(&String.replace("#{&1}", "_", " "))
+    |> pretty_join()
+  end
+
+  def format_date_range(date_range) do
+    "#{format_date(date_range.first)} - #{format_date(date_range.last)}"
+  end
+
+  def format_date(date) do
+    Calendar.strftime(date, "%b %-d, %Y")
+  end
+
+  def number_format(number) when is_integer(number) do
+    Cldr.Number.to_string!(number)
+  end
+
+  def number_format(other), do: other
+end

lib/plausible_web/views/unsubscribe_view.ex

@@ -0,0 +1,3 @@
+defmodule PlausibleWeb.UnsubscribeView do
+  use PlausibleWeb, :view
+end

lib/sentry_filter.ex

@@ -0,0 +1,69 @@
+defmodule Plausible.SentryFilter do
+  @moduledoc """
+  Sentry callbacks for filtering and grouping events
+  """
+
+  @spec before_send(Sentry.Event.t()) :: Sentry.Event.t()
+  def before_send(event)
+
+  def before_send(%{original_exception: %Bamboo.PostmarkAdapter.Error{} = e} = event) do
+    if Bamboo.PostmarkAdapter.Error.is_hard_bounce(e), do: false, else: event
+  end
+
+  def before_send(%{original_exception: %Phoenix.NotAcceptableError{}}), do: false
+  def before_send(%{original_exception: %Plug.CSRFProtection.InvalidCSRFTokenError{}}), do: false
+  def before_send(%{original_exception: %Plug.Static.InvalidPathError{}}), do: false
+
+  def before_send(
+        %{
+          exception: [%{type: "DBConnection.ConnectionError"}],
+          original_exception: %{reason: reason}
+        } = event
+      ) do
+    %{event | fingerprint: ["db_connection", reason]}
+  end
+
+  def before_send(
+        %{
+          exception: [%{type: "Mint.TransportError"}],
+          original_exception: %{reason: reason}
+        } = event
+      ) do
+    %{event | fingerprint: ["mint_transport", reason]}
+  end
+
+  def before_send(
+        %{
+          exception: [%{type: "Finch.TransportError"}],
+          original_exception: %{reason: reason}
+        } = event
+      ) do
+    %{event | fingerprint: ["mint_transport", reason]}
+  end
+
+  def before_send(
+        %{source: :logger, message: %{formatted: "Ch.Connection (#PID<" <> rest}} = event
+      ) do
+    if String.ends_with?(rest, ")) disconnected: ** (Mint.HTTPError) the connection is closed") do
+      false
+    else
+      event
+    end
+  end
+
+  def before_send(%{extra: %{request: %Plausible.Ingestion.Request{}}} = event) do
+    %{event | fingerprint: ["ingestion_request"]}
+  end
+
+  def before_send(%{source: :logger, message: %{formatted: "Ranch listener" <> rest}} = event) do
+    if String.contains?(rest, "had its request process") do
+      false
+    else
+      event
+    end
+  end
+
+  def before_send(event) do
+    event
+  end
+end

lib/workers/accept_traffic_until_notification.ex

@@ -0,0 +1,106 @@
+defmodule Plausible.Workers.AcceptTrafficUntil do
+  @moduledoc """
+  A worker meant to be run once a day that sends out e-mail notifications to site
+  owners assuming:
+    - their sites still receive traffic (i.e. have stats for yesterday)
+    - `site.accept_traffic_until` is approaching either tomorrow or exactly in 7 days
+
+  Users having no sites or sites that receive no traffic, won't be notified.
+  We make a tiny effort here to make sure we send the same notification at most once a day.
+  """
+  use Oban.Worker, queue: :check_accept_traffic_until
+  import Ecto.Query
+
+  alias Plausible.Repo
+  alias Plausible.ClickhouseRepo
+
+  def dry_run(date) do
+    perform(nil, date, true)
+  end
+
+  @impl Oban.Worker
+  def perform(_job, today \\ Date.utc_today(), dry_run? \\ false) do
+    tomorrow = today |> Date.add(+1)
+    next_week = today |> Date.add(+7)
+
+    # send at most one notification per user, per day
+    sent_today_query =
+      from s in "sent_accept_traffic_until_notifications",
+        where: s.user_id == parent_as(:users).id and s.sent_on == ^today,
+        select: true
+
+    notifications =
+      Repo.all(
+        from t in Plausible.Teams.Team,
+          inner_join: u in assoc(t, :owners),
+          as: :users,
+          inner_join: s in assoc(t, :sites),
+          where: t.accept_traffic_until == ^tomorrow or t.accept_traffic_until == ^next_week,
+          where: not exists(sent_today_query),
+          select: %{
+            id: u.id,
+            email: u.email,
+            deadline: t.accept_traffic_until,
+            site_ids: fragment("array_agg(?.id)", s),
+            name: u.name,
+            team: t
+          },
+          group_by: [u.id, t.id]
+      )
+
+    for notification <- notifications do
+      case {has_stats?(notification.site_ids, today), notification.deadline} do
+        {true, ^tomorrow} ->
+          if dry_run? do
+            IO.puts("Will send final notification to #{notification.email}")
+          else
+            notification
+            |> store_sent(today)
+            |> PlausibleWeb.Email.approaching_accept_traffic_until_tomorrow()
+            |> Plausible.Mailer.send()
+          end
+
+        {true, ^next_week} ->
+          if dry_run? do
+            IO.puts("Will send weekly notification to #{notification.email}")
+          else
+            notification
+            |> store_sent(today)
+            |> PlausibleWeb.Email.approaching_accept_traffic_until()
+            |> Plausible.Mailer.send()
+          end
+
+        _ ->
+          nil
+      end
+    end
+
+    {:ok, Enum.count(notifications)}
+  end
+
+  defp has_stats?(site_ids, today) do
+    ago_2d = Date.add(today, -2)
+
+    ClickhouseRepo.exists?(
+      from e in "events_v2",
+        where: fragment("toDate(?) >= ?", e.timestamp, ^ago_2d),
+        where: e.site_id in ^site_ids
+    )
+  end
+
+  defp store_sent(notification, today) do
+    Repo.insert_all(
+      "sent_accept_traffic_until_notifications",
+      [
+        %{
+          user_id: notification.id,
+          sent_on: today
+        }
+      ],
+      on_conflict: :nothing,
+      conflict_target: [:user_id, :sent_on]
+    )
+
+    notification
+  end
+end

lib/workers/check_usage.ex

@@ -0,0 +1,170 @@
+defmodule Plausible.Workers.CheckUsage do
+  use Plausible.Repo
+  use Oban.Worker, queue: :check_usage
+  require Plausible.Billing.Subscription.Status
+  alias Plausible.Billing.{Subscription, Quota}
+  alias Plausible.Teams
+
+  defmacro yesterday() do
+    quote do
+      fragment("now() - INTERVAL '1 day'")
+    end
+  end
+
+  defmacro last_day_of_month(day) do
+    quote do
+      fragment(
+        "(date_trunc('month', ?::date) + interval '1 month' - interval '1 day')::date",
+        unquote(day)
+      )
+    end
+  end
+
+  defmacro day_of_month(date) do
+    quote do
+      fragment("EXTRACT(day from ?::date)", unquote(date))
+    end
+  end
+
+  defmacro least(left, right) do
+    quote do
+      fragment("least(?, ?)", unquote(left), unquote(right))
+    end
+  end
+
+  @impl Oban.Worker
+  def perform(_job, usage_mod \\ Teams.Billing, today \\ Date.utc_today()) do
+    yesterday = today |> Date.shift(day: -1)
+
+    active_subscribers =
+      Repo.all(
+        from(t in Teams.Team,
+          as: :team,
+          inner_join: o in assoc(t, :owners),
+          left_join: bm in assoc(t, :billing_members),
+          inner_lateral_join: s in subquery(Teams.last_subscription_join_query()),
+          on: true,
+          left_join: ep in Plausible.Billing.EnterprisePlan,
+          on: ep.team_id == t.id and ep.paddle_plan_id == s.paddle_plan_id,
+          where:
+            s.status in [
+              ^Subscription.Status.active(),
+              ^Subscription.Status.past_due(),
+              ^Subscription.Status.deleted()
+            ],
+          where: not is_nil(s.last_bill_date),
+          # Accounts for situations like last_bill_date==2021-01-31 AND today==2021-03-01. Since February never reaches the 31st day, the account is checked on 2021-03-01.
+          where: s.next_bill_date >= ^today,
+          where:
+            least(day_of_month(s.last_bill_date), day_of_month(last_day_of_month(^yesterday))) ==
+              day_of_month(^yesterday),
+          order_by: t.id,
+          preload: [subscription: s, enterprise_plan: ep, owners: o, billing_members: bm]
+        )
+      )
+
+    for subscriber <- active_subscribers do
+      case {subscriber.grace_period, subscriber.enterprise_plan} do
+        {nil, nil} ->
+          check_regular_subscriber(subscriber, usage_mod)
+
+        {nil, _} ->
+          check_enterprise_subscriber(subscriber, usage_mod)
+
+        {_, nil} ->
+          maybe_remove_grace_period(subscriber, usage_mod)
+
+        _ ->
+          :skip
+      end
+    end
+
+    :ok
+  end
+
+  defp check_site_usage_for_enterprise(subscriber) do
+    limit = subscriber.enterprise_plan.site_limit
+
+    usage = Teams.Billing.site_usage(subscriber)
+
+    if Quota.below_limit?(usage, limit) do
+      {:below_limit, {usage, limit}}
+    else
+      {:over_limit, {usage, limit}}
+    end
+  end
+
+  def maybe_remove_grace_period(subscriber, usage_mod) do
+    case check_pageview_usage_last_cycle(subscriber, usage_mod) do
+      {:below_limit, _} ->
+        Plausible.Teams.remove_grace_period(subscriber)
+        :ok
+
+      _ ->
+        :skip
+    end
+  end
+
+  defp check_regular_subscriber(subscriber, usage_mod) do
+    case check_pageview_usage_two_cycles(subscriber, usage_mod) do
+      {:over_limit, pageview_usage} ->
+        suggested_volume =
+          Plausible.Billing.Plans.suggest_volume(subscriber, pageview_usage.last_cycle.total)
+
+        for owner <- subscriber.owners ++ subscriber.billing_members do
+          PlausibleWeb.Email.over_limit_email(owner, subscriber, pageview_usage, suggested_volume)
+          |> Plausible.Mailer.send()
+        end
+
+        Plausible.Teams.start_grace_period(subscriber)
+
+      _ ->
+        nil
+    end
+  end
+
+  def check_enterprise_subscriber(subscriber, usage_mod) do
+    pageview_usage = check_pageview_usage_two_cycles(subscriber, usage_mod)
+    site_usage = check_site_usage_for_enterprise(subscriber)
+
+    case {pageview_usage, site_usage} do
+      {{:below_limit, _}, {:below_limit, _}} ->
+        nil
+
+      {{_, pageview_usage}, {_, {site_usage, site_allowance}}} ->
+        for owner <- subscriber.owners ++ subscriber.billing_members do
+          PlausibleWeb.Email.enterprise_over_limit_internal_email(
+            owner,
+            pageview_usage,
+            site_usage,
+            site_allowance
+          )
+          |> Plausible.Mailer.send()
+        end
+
+        Plausible.Teams.start_manual_lock_grace_period(subscriber)
+    end
+  end
+
+  def check_pageview_usage_two_cycles(subscriber, usage_mod) do
+    usage = usage_mod.monthly_pageview_usage(subscriber)
+    limit = Teams.Billing.monthly_pageview_limit(subscriber.subscription)
+
+    if Quota.exceeds_last_two_usage_cycles?(usage, limit) do
+      {:over_limit, usage}
+    else
+      {:below_limit, usage}
+    end
+  end
+
+  defp check_pageview_usage_last_cycle(subscriber, usage_mod) do
+    usage = usage_mod.monthly_pageview_usage(subscriber)
+    limit = Teams.Billing.monthly_pageview_limit(subscriber.subscription)
+
+    if :last_cycle in Quota.exceeded_cycles(usage, limit) do
+      {:over_limit, usage}
+    else
+      {:below_limit, usage}
+    end
+  end
+end

lib/workers/clean_invitations.ex

@@ -0,0 +1,25 @@
+defmodule Plausible.Workers.CleanInvitations do
+  use Plausible.Repo
+  use Oban.Worker, queue: :clean_invitations
+
+  @cutoff Duration.new!(hour: -48)
+
+  @impl Oban.Worker
+  def perform(_job) do
+    cutoff_time =
+      NaiveDateTime.utc_now(:second)
+      |> NaiveDateTime.shift(@cutoff)
+
+    Repo.delete_all(
+      from ti in Plausible.Teams.Invitation,
+        where: ti.inserted_at < ^cutoff_time
+    )
+
+    Repo.delete_all(
+      from ti in Plausible.Teams.SiteTransfer,
+        where: ti.inserted_at < ^cutoff_time
+    )
+
+    :ok
+  end
+end

lib/workers/clean_user_sessions.ex

@@ -0,0 +1,27 @@
+defmodule Plausible.Workers.CleanUserSessions do
+  @moduledoc """
+  Job removing expired user sessions. A grace period is applied.
+  """
+
+  use Plausible.Repo
+  use Oban.Worker, queue: :clean_user_sessions
+
+  @grace_period Duration.new!(day: -7)
+
+  @spec grace_period_duration() :: Duration.t()
+  def grace_period_duration(), do: @grace_period
+
+  @impl Oban.Worker
+  def perform(_job) do
+    grace_cutoff =
+      NaiveDateTime.utc_now(:second)
+      |> NaiveDateTime.shift(@grace_period)
+
+    Repo.delete_all(
+      from us in Plausible.Auth.UserSession,
+        where: us.timeout_at < ^grace_cutoff
+    )
+
+    :ok
+  end
+end

lib/workers/clickhouse_clean_sites.ex

@@ -0,0 +1,81 @@
+defmodule Plausible.Workers.ClickhouseCleanSites do
+  @moduledoc """
+  Cleans deleted site data from ClickHouse asynchronously.
+
+  We batch up data deletions from ClickHouse as deleting a single site is
+  just as expensive as deleting many.
+  """
+
+  use Plausible.Repo
+  use Plausible.ClickhouseRepo
+  use Plausible.IngestRepo
+  use Oban.Worker, queue: :clickhouse_clean_sites
+
+  import Ecto.Query
+
+  require Logger
+
+  @tables_to_clear [
+    "events_v2",
+    "sessions_v2",
+    "ingest_counters",
+    "imported_browsers",
+    "imported_devices",
+    "imported_entry_pages",
+    "imported_exit_pages",
+    "imported_locations",
+    "imported_operating_systems",
+    "imported_pages",
+    "imported_custom_events",
+    "imported_sources",
+    "imported_visitors"
+  ]
+
+  @settings if Mix.env() in [:test, :ce_test, :e2e_test], do: [mutations_sync: 2], else: []
+
+  def perform(_job) do
+    deleted_sites = get_deleted_sites_with_clickhouse_data()
+
+    if not Enum.empty?(deleted_sites) do
+      Logger.notice(
+        "Clearing ClickHouse data for the following #{length(deleted_sites)} sites which have been deleted: #{inspect(deleted_sites)}"
+      )
+
+      for table <- @tables_to_clear do
+        IngestRepo.query!(
+          "ALTER TABLE {$0:Identifier} DELETE WHERE site_id IN {$1:Array(UInt64)}",
+          [table, deleted_sites],
+          settings: @settings
+        )
+      end
+    end
+
+    :ok
+  end
+
+  def get_deleted_sites_with_clickhouse_data() do
+    pg_sites =
+      from(s in Plausible.Site.regular(), select: s.id)
+      |> Plausible.Repo.all()
+      |> MapSet.new()
+
+    {:ok, ch} =
+      Plausible.ClickhouseRepo.get_config_without_ch_query_execution_timeout()
+      |> Ch.start_link()
+
+    %Ch.Result{columns: ["site_id"], rows: rows} =
+      DBConnection.run(
+        ch,
+        fn conn ->
+          Ch.query!(conn, "FROM events_v2 SELECT site_id GROUP BY site_id", [],
+            timeout: :infinity
+          )
+        end,
+        timeout: :infinity
+      )
+
+    ch_sites = rows |> MapSet.new(fn [site_id] -> site_id end)
+
+    MapSet.difference(ch_sites, pg_sites) |> MapSet.to_list()
+  end
+end

lib/workers/expire_domain_change_transitions.ex

@@ -0,0 +1,22 @@
+defmodule Plausible.Workers.ExpireDomainChangeTransitions do
+  @moduledoc """
+  Periodic worker that expires domain change transition period.
+  Old domains are frozen for a given time, so users can still access them
+  before redeploying their scripts and integrations.
+  """
+  use Plausible.Repo
+  use Oban.Worker, queue: :domain_change_transition
+
+  require Logger
+
+  @impl Oban.Worker
+  def perform(_job) do
+    {:ok, n} = Plausible.Site.Domain.expire_change_transitions()
+
+    if n > 0 do
+      Logger.warning("Expired #{n} from the domain change transition period.")
+    end
+
+    :ok
+  end
+end

lib/workers/export_analytics.ex

@@ -0,0 +1,121 @@
+defmodule Plausible.Workers.ExportAnalytics do
+  @moduledoc """
+  Worker for running CSV export jobs. Supports S3 and local storage.
+  To avoid blocking the queue, a timeout of 15 minutes is enforced.
+  """
+
+  use Oban.Worker,
+    queue: :analytics_exports,
+    max_attempts: 3
+
+  alias Plausible.Exports
+
+  @doc "This base query filters export jobs for a site"
+  def base_query(site_id) do
+    import Ecto.Query, only: [from: 2]
+
+    from j in Oban.Job,
+      where: j.worker == ^Oban.Worker.to_string(__MODULE__),
+      where: j.args["site_id"] == ^site_id
+  end
+
+  @impl true
+  def timeout(_job), do: :timer.minutes(15)
+
+  @impl true
+  def perform(%Oban.Job{args: args} = job) do
+    %{
+      "storage" => storage,
+      "site_id" => site_id
+    } = args
+
+    site = Plausible.Repo.get!(Plausible.Site, site_id)
+    true = Plausible.Sites.regular?(site)
+    %Date.Range{} = date_range = Exports.date_range(site.id, site.timezone)
+
+    queries =
+      Exports.export_queries(site,
+        date_range: date_range,
+        timezone: site.timezone,
+        extname: ".csv"
+      )
+
+    # since each worker / `perform` attempt runs in a separate process
+    # it's ok to use start_link to keep connection lifecycle
+    # bound to that of the worker
+    {:ok, ch} =
+      Plausible.ClickhouseRepo.get_config_without_ch_query_execution_timeout()
+      |> Ch.start_link()
+
+    try do
+      case storage do
+        "s3" -> perform_s3_export(ch, site, queries, args)
+        "local" -> perform_local_export(ch, queries, args)
+      end
+    after
+      Exports.oban_notify(site_id)
+    end
+
+    email_success(job.args)
+
+    :ok
+  catch
+    class, reason ->
+      if job.attempt >= job.max_attempts, do: email_failure(job.args)
+      :erlang.raise(class, reason, __STACKTRACE__)
+  end
+
+  defp perform_s3_export(ch, site, queries, args) do
+    %{
+      "s3_bucket" => s3_bucket,
+      "s3_path" => s3_path
+    } = args
+
+    created_on = Plausible.Timezones.to_date_in_timezone(DateTime.utc_now(), site.timezone)
+    filename = Exports.archive_filename(site.domain, created_on)
+
+    DBConnection.run(
+      ch,
+      fn conn ->
+        conn
+        |> Exports.stream_archive(queries, format: "CSVWithNames", timeout: :infinity)
+        |> Plausible.S3.export_upload_multipart(s3_bucket, s3_path, filename)
+      end,
+      timeout: :infinity
+    )
+  end
+
+  defp perform_local_export(ch, queries, args) do
+    %{"local_path" => local_path} = args
+    tmp_path = Plug.Upload.random_file!("tmp-plausible-export")
+
+    DBConnection.run(
+      ch,
+      fn conn ->
+        Exports.stream_archive(conn, queries, format: "CSVWithNames")
+        |> Stream.into(File.stream!(tmp_path))
+        |> Stream.run()
+      end,
+      timeout: :infinity
+    )
+
+    File.mkdir_p!(Path.dirname(local_path))
+    if File.exists?(local_path), do: File.rm!(local_path)
+    Plausible.File.mv!(tmp_path, local_path)
+  end
+
+  defp email_failure(args) do
+    args |> Map.put("status", "failure") |> email()
+  end
+
+  defp email_success(args) do
+    args |> Map.put("status", "success") |> email()
+  end
+
+  defp email(args) do
+    # email delivery can potentially fail and cause already successful
+    # export to be repeated which is costly, hence email is delivered
+    # in a separate job
+    Oban.insert!(Plausible.Workers.NotifyExportedAnalytics.new(args))
+  end
+end

lib/workers/import_analytics.ex

@@ -0,0 +1,96 @@
+defmodule Plausible.Workers.ImportAnalytics do
+  @moduledoc """
+  Worker for running analytics import jobs.
+  """
+
+  use Plausible.Repo
+
+  use Oban.Worker,
+    queue: :analytics_imports,
+    max_attempts: 3,
+    unique: [fields: [:args], keys: [:import_id], period: 60]
+
+  alias Plausible.Imported.ImportSources
+  alias Plausible.Imported.Importer
+  alias Plausible.Imported.SiteImport
+
+  @impl Oban.Worker
+  def perform(%Oban.Job{
+        args: %{"import_id" => import_id} = args
+      }) do
+    site_import =
+      SiteImport
+      |> Repo.get!(import_id)
+      |> Repo.preload(:site)
+
+    import_api = ImportSources.by_name(site_import.source)
+
+    case import_api.run_import(site_import, args) do
+      {:ok, site_import} ->
+        import_complete(site_import)
+
+        :ok
+
+      {:error, error, error_opts} ->
+        Sentry.capture_message("Failed to import from #{site_import.source}",
+          extra: %{
+            import_id: site_import.id,
+            site: site_import.site.domain,
+            error: inspect(error)
+          }
+        )
+
+        import_fail(site_import, error_opts)
+
+        {:discard, error}
+    end
+  end
+
+  @impl Oban.Worker
+  def backoff(_job) do
+    # 5 minutes
+    300
+  end
+
+  def import_complete(site_import) do
+    site_import = Repo.preload(site_import, [:imported_by, site: :team])
+
+    PlausibleWeb.Email.import_success(site_import, site_import.imported_by)
+    |> Plausible.Mailer.send()
+
+    Plausible.Sites.clear_stats_start_date!(site_import.site)
+
+    Importer.notify(site_import, :complete)
+
+    :ok
+  end
+
+  def import_fail_transient(site_import) do
+    Plausible.Purge.delete_imported_stats!(site_import)
+
+    Importer.notify(site_import, :transient_fail)
+  end
+
+  def import_fail(site_import, opts) do
+    skip_purge? = Keyword.get(opts, :skip_purge?, false)
+    skip_mark_failed? = Keyword.get(opts, :skip_mark_failed?, false)
+
+    if not skip_purge? do
+      Plausible.Purge.delete_imported_stats!(site_import)
+    end
+
+    if not skip_mark_failed? do
+      import_api = ImportSources.by_name(site_import.source)
+
+      site_import =
+        site_import
+        |> import_api.mark_failed()
+        |> Repo.preload([:site, :imported_by])
+
+      Importer.notify(site_import, :fail)
+
+      PlausibleWeb.Email.import_failure(site_import, site_import.imported_by)
+      |> Plausible.Mailer.send()
+    end
+  end
+end

lib/workers/local_import_analytics_cleaner.ex

@@ -0,0 +1,32 @@
+defmodule Plausible.Workers.LocalImportAnalyticsCleaner do
+  @moduledoc """
+  Worker for cleaning local files left after analytics import jobs.
+  """
+
+  use Oban.Worker, queue: :analytics_imports, unique: [period: 3600]
+
+  @impl Oban.Worker
+  def perform(%Oban.Job{args: args}) do
+    %{"import_id" => import_id, "paths" => paths} = args
+
+    if import_in_progress?(import_id) do
+      {:snooze, _one_hour = 3600}
+    else
+      Enum.each(paths, fn path ->
+        # credo:disable-for-next-line Credo.Check.Refactor.Nesting
+        if File.exists?(path), do: File.rm!(path)
+      end)
+    end
+  end
+
+  defp import_in_progress?(import_id) do
+    import Ecto.Query
+    require Plausible.Imported.SiteImport
+    alias Plausible.Imported.SiteImport
+
+    SiteImport
+    |> where(id: ^import_id)
+    |> where([i], i.status in ^[SiteImport.pending(), SiteImport.importing()])
+    |> Plausible.Repo.exists?()
+  end
+end

lib/workers/locations_sync.ex

@@ -0,0 +1,15 @@
+defmodule Plausible.Workers.LocationsSync do
+  @moduledoc false
+
+  use Plausible.Repo
+  use Oban.Worker, queue: :locations_sync
+
+  @impl Oban.Worker
+  def perform(_job) do
+    if Plausible.DataMigration.LocationsSync.out_of_date?() do
+      Plausible.DataMigration.LocationsSync.run()
+    end
+
+    :ok
+  end
+end

lib/workers/lock_sites.ex

@@ -0,0 +1,24 @@
+defmodule Plausible.Workers.LockSites do
+  use Plausible.Repo
+  use Oban.Worker, queue: :lock_sites
+
+  alias Plausible.Teams
+
+  @impl Oban.Worker
+  def perform(_job) do
+    teams =
+      Repo.all(
+        from t in Teams.Team,
+          as: :team,
+          left_lateral_join: s in subquery(Teams.last_subscription_join_query()),
+          on: true,
+          preload: [subscription: s]
+      )
+
+    for team <- teams do
+      Plausible.Billing.SiteLocker.update_for(team)
+    end
+
+    :ok
+  end
+end

lib/workers/notify_annual_renewal.ex

@@ -0,0 +1,76 @@
+defmodule Plausible.Workers.NotifyAnnualRenewal do
+  use Plausible.Repo
+  use Oban.Worker, queue: :notify_annual_renewal
+
+  require Plausible.Billing.Subscription.Status
+
+  alias Money.Subscription
+  alias Plausible.Billing.Subscription
+  alias Plausible.Teams
+
+  @yearly_plans Plausible.Billing.Plans.yearly_product_ids()
+
+  @impl Oban.Worker
+  @doc """
+  Sends a notification at most 7 days and at least 1 day before the renewal of an annual subscription
+  """
+  def perform(_job) do
+    sent_notification =
+      from(
+        s in "sent_renewal_notifications",
+        where: s.timestamp > fragment("now() - INTERVAL '1 month'")
+      )
+
+    teams =
+      Repo.all(
+        from t in Teams.Team,
+          as: :team,
+          inner_join: o in assoc(t, :owners),
+          left_join: bm in assoc(t, :billing_members),
+          inner_lateral_join: s in subquery(Teams.last_subscription_join_query()),
+          on: true,
+          left_join: sent in ^sent_notification,
+          on: o.id == sent.user_id,
+          where: is_nil(sent.id),
+          where: s.paddle_plan_id in @yearly_plans,
+          where:
+            s.next_bill_date > fragment("now()::date") and
+              s.next_bill_date <= fragment("now()::date + INTERVAL '7 days'"),
+          preload: [owners: o, subscription: s, billing_members: bm]
+      )
+
+    for team <- teams do
+      recipients = team.owners ++ team.billing_members
+
+      case team.subscription.status do
+        Subscription.Status.active() ->
+          for recipient <- recipients do
+            template = PlausibleWeb.Email.yearly_renewal_notification(team, recipient)
+            Plausible.Mailer.send(template)
+          end
+
+        Subscription.Status.deleted() ->
+          for recipient <- recipients do
+            template = PlausibleWeb.Email.yearly_expiration_notification(team, recipient)
+            Plausible.Mailer.send(template)
+          end
+
+        _ ->
+          Sentry.capture_message("Invalid subscription for renewal",
+            team: team
+          )
+      end
+
+      for recipient <- recipients do
+        Repo.insert_all("sent_renewal_notifications", [
+          %{
+            user_id: recipient.id,
+            timestamp: NaiveDateTime.utc_now()
+          }
+        ])
+      end
+    end
+
+    :ok
+  end
+end

lib/workers/notify_exported_analytics.ex

@@ -0,0 +1,43 @@
+defmodule Plausible.Workers.NotifyExportedAnalytics do
+  @moduledoc "This worker delivers emails for successful and failed exports"
+
+  use Oban.Worker,
+    queue: :notify_exported_analytics,
+    max_attempts: 5
+
+  @impl true
+  def perform(%Oban.Job{args: args}) do
+    %{
+      "status" => status,
+      "storage" => storage,
+      "email_to" => email_to,
+      "site_id" => site_id
+    } = args
+
+    user = Plausible.Repo.get_by!(Plausible.Auth.User, email: email_to)
+
+    site =
+      Plausible.Site
+      |> Plausible.Repo.get!(site_id)
+      |> Plausible.Repo.preload(:team)
+
+    email =
+      case status do
+        "success" ->
+          case storage do
+            "s3" ->
+              %{expires_at: expires_at} = Plausible.Exports.get_s3_export!(site_id, _retries = 10)
+              PlausibleWeb.Email.export_success(user, site, expires_at)
+
+            "local" ->
+              PlausibleWeb.Email.export_success(user, site, _expires_at = nil)
+          end
+
+        "failure" ->
+          PlausibleWeb.Email.export_failure(user, site)
+      end
+
+    Plausible.Mailer.deliver_now!(email)
+    :ok
+  end
+end

lib/workers/purge_cdn_cache.ex

@@ -0,0 +1,71 @@
+defmodule Plausible.Workers.PurgeCDNCache do
+  @moduledoc """
+  Worker for purging CDN cache for tracker scripts on cloud.
+
+  Uses Bunny CDN's API to purge cache by tag.
+  Docs ref: https://docs.bunny.net/reference/pullzonepublic_purgecachepostbytag
+
+  Note that purging by id "*" is equivalent to purging ALL cache.
+  """
+
+  use Oban.Worker,
+    queue: :purge_cdn_cache,
+    max_attempts: 5,
+    # To avoid running into API rate limits, we:
+    # - Schedule jobs with a delay
+    # - Bump the scheduled time every time a new one is scheduled with the same args
+    unique: [
+      states: [:scheduled],
+      fields: [:args]
+    ]
+
+  require Logger
+
+  @impl Oban.Worker
+  def perform(%Oban.Job{args: %{"id" => id}}) do
+    pullzone_id = Application.get_env(:plausible, __MODULE__, [])[:pullzone_id]
+    api_key = Application.get_env(:plausible, __MODULE__, [])[:api_key]
+
+    purge_cache(id, pullzone_id, api_key)
+  end
+
+  @impl Oban.Worker
+  def backoff(%Oban.Job{attempt: attempt}) do
+    # Exponential backoff starting at 3 minutes
+    trunc(:math.pow(2, attempt - 1) * 180)
+  end
+
+  defp purge_cache(id, pullzone_id, api_key) when is_nil(pullzone_id) or is_nil(api_key) do
+    Logger.warning("Ignoring purge CDN cache for tracker script #{id}: Configuration missing")
+    {:discard, "Configuration missing"}
+  end
+
+  defp purge_cache(id, pullzone_id, api_key) do
+    options =
+      [
+        headers: [
+          {"content-type", "application/json"},
+          {"AccessKey", api_key}
+        ],
+        body: Jason.encode!(%{"CacheTag" => "tracker_script::#{id}"})
+      ]
+      |> Keyword.merge(Application.get_env(:plausible, __MODULE__)[:req_opts] || [])
+
+    case Req.post("https://api.bunny.net/pullzone/#{pullzone_id}/purgeCache", options) do
+      {:ok, %{status: 204}} ->
+        Logger.notice("Successfully purged CDN cache for tracker script #{id}")
+        {:ok, :success}
+
+      {:ok, %{status: status}} ->
+        Logger.warning(
+          "Failed to purge CDN cache for tracker script #{id}: Unexpected status: #{status}"
+        )
+
+        {:error, "Unexpected status: #{status}"}
+
+      {:error, reason} ->
+        Logger.warning("Failed to purge CDN cache for tracker script #{id}: #{inspect(reason)}")
+        {:error, reason}
+    end
+  end
+end

lib/workers/rotate_salts.ex

@@ -0,0 +1,9 @@
+defmodule Plausible.Workers.RotateSalts do
+  use Plausible.Repo
+  use Oban.Worker, queue: :rotate_salts
+
+  @impl Oban.Worker
+  def perform(_job) do
+    Plausible.Session.Salts.rotate()
+  end
+end

lib/workers/schedule_email_reports.ex

@@ -0,0 +1,100 @@
+defmodule Plausible.Workers.ScheduleEmailReports do
+  @moduledoc """
+  Job scheduling dispatch of weekly and monthly email reports.
+  """
+  use Plausible.Repo
+  use Oban.Worker, queue: :schedule_email_reports
+  alias Plausible.Workers.SendEmailReport
+
+  @impl Oban.Worker
+  @doc """
+  Email reports should be sent on Monday at 9am according to the timezone
+  of a site.
+  """
+  def perform(_job) do
+    schedule_weekly_emails()
+    schedule_monthly_emails()
+  end
+
+  defp schedule_weekly_emails() do
+    weekly_jobs =
+      from(
+        j in Oban.Job,
+        where:
+          j.worker == "Plausible.Workers.SendEmailReport" and
+            fragment("(? ->> 'interval')", j.args) == "weekly"
+      )
+
+    sites =
+      Repo.all(
+        from s in Plausible.Site,
+          inner_join: t in assoc(s, :team),
+          join: wr in Plausible.Site.WeeklyReport,
+          on: wr.site_id == s.id,
+          left_join: job in subquery(weekly_jobs),
+          on:
+            fragment("(? -> 'site_id')::int", job.args) == s.id and
+              job.state not in ["completed", "discarded"],
+          where: is_nil(job),
+          where: not t.locked,
+          preload: [weekly_report: wr]
+      )
+
+    for site <- sites do
+      SendEmailReport.new(%{site_id: site.id, interval: "weekly"},
+        scheduled_at: monday_9am(site.timezone)
+      )
+      |> Oban.insert!()
+    end
+
+    :ok
+  end
+
+  def monday_9am(timezone) do
+    DateTime.now!(timezone)
+    |> DateTime.shift(week: 1)
+    |> Plausible.Times.beginning_of_week()
+    |> DateTime.shift(hour: 9)
+  end
+
+  defp schedule_monthly_emails() do
+    monthly_jobs =
+      from(
+        j in Oban.Job,
+        where:
+          j.worker == "Plausible.Workers.SendEmailReport" and
+            fragment("(? ->> 'interval')", j.args) == "monthly"
+      )
+
+    sites =
+      Repo.all(
+        from s in Plausible.Site,
+          inner_join: t in assoc(s, :team),
+          join: mr in Plausible.Site.MonthlyReport,
+          on: mr.site_id == s.id,
+          left_join: job in subquery(monthly_jobs),
+          on:
+            fragment("(? -> 'site_id')::int", job.args) == s.id and
+              job.state not in ["completed", "discarded"],
+          where: is_nil(job),
+          where: not t.locked,
+          preload: [monthly_report: mr]
+      )
+
+    for site <- sites do
+      SendEmailReport.new(%{site_id: site.id, interval: "monthly"},
+        scheduled_at: first_of_month_9am(site.timezone)
+      )
+      |> Oban.insert!()
+    end
+
+    :ok
+  end
+
+  def first_of_month_9am(timezone) do
+    DateTime.now!(timezone)
+    |> DateTime.shift(month: 1)
+    |> Plausible.Times.beginning_of_month()
+    |> DateTime.shift(hour: 9)
+  end
+end

lib/workers/send_check_stats_emails.ex

@@ -0,0 +1,55 @@
+defmodule Plausible.Workers.SendCheckStatsEmails do
+  use Plausible.Repo
+  use Oban.Worker, queue: :check_stats_emails
+
+  @impl Oban.Worker
+  def perform(_job) do
+    q =
+      from(u in Plausible.Auth.User,
+        left_join: ce in "check_stats_emails",
+        on: ce.user_id == u.id,
+        where: is_nil(ce.id),
+        where:
+          u.inserted_at > fragment("(now() at time zone 'utc') - '14 days'::interval") and
+            u.inserted_at < fragment("(now() at time zone 'utc') - '7 days'::interval") and
+            u.last_seen < fragment("(now() at time zone 'utc') - '7 days'::interval")
+      )
+
+    for user <- Repo.all(q) do
+      if eligible_for_check_stats_email?(user) do
+        send_check_stats_email(user)
+      end
+    end
+
+    :ok
+  end
+
+  defp eligible_for_check_stats_email?(user) do
+    sites =
+      from(tm in Plausible.Teams.Membership,
+        inner_join: t in assoc(tm, :team),
+        inner_join: s in assoc(t, :sites),
+        left_join: gm in assoc(tm, :guest_memberships),
+        where: tm.user_id == ^user.id,
+        where: tm.role != :guest or gm.site_id == s.id,
+        select: s
+      )
+      |> Repo.all()
+      |> Repo.preload(:weekly_report)
+
+    not Enum.any?(sites, fn site -> site.weekly_report end) and
+      Enum.any?(sites, &Plausible.Sites.has_stats?/1)
+  end
+
+  defp send_check_stats_email(user) do
+    PlausibleWeb.Email.check_stats_email(user)
+    |> Plausible.Mailer.send()
+
+    Repo.insert_all("check_stats_emails", [
+      %{
+        user_id: user.id,
+        timestamp: NaiveDateTime.utc_now()
+      }
+    ])
+  end
+end

lib/workers/send_email_report.ex

@@ -0,0 +1,210 @@
+defmodule Plausible.Workers.SendEmailReport do
+  use Plausible
+  use Plausible.Repo
+  use Oban.Worker, queue: :send_email_reports, max_attempts: 1
+
+  alias Plausible.Stats.{QueryResult, QueryBuilder, ParsedQueryParams, QueryInclude}
+
+  import Ecto.Query, only: [from: 2]
+
+  @weekly "weekly"
+  @monthly "monthly"
+
+  def perform(%Oban.Job{args: %{"interval" => interval, "site_id" => site_id}})
+      when interval in [@weekly, @monthly] do
+    report_type = report_type(interval)
+
+    site =
+      from(s in Plausible.Site,
+        where: s.id == ^site_id,
+        inner_join: r in assoc(s, ^report_type),
+        inner_join: t in assoc(s, :team),
+        preload: [{^report_type, r}, {:team, t}]
+      )
+      |> Repo.one()
+
+    with %Plausible.Site{} <- site,
+         %{} = report <- Map.fetch!(site, report_type),
+         true <- ok_to_send?(site) do
+      date_range = date_range(site, interval)
+      report_name = report_name(interval, date_range.first)
+      date_label = Calendar.strftime(date_range.last, "%-d %b %Y")
+      stats = stats(site, date_range)
+
+      report
+      |> Map.fetch!(:recipients)
+      |> Enum.each(fn email ->
+        assigns = %{
+          site: site,
+          report_name: report_name,
+          date_label: date_label,
+          unsubscribe_link: unsubscribe_link(site, email, interval),
+          site_member?: site_member?(site, email),
+          interval: interval,
+          stats: stats
+        }
+
+        email
+        |> PlausibleWeb.Email.stats_report(assigns)
+        |> Plausible.Mailer.send()
+      end)
+    else
+      _ -> :discard
+    end
+  end
+
+  defp report_type(@weekly), do: :weekly_report
+  defp report_type(@monthly), do: :monthly_report
+
+  defp site_member?(site, email) do
+    user = Plausible.Auth.find_user_by(email: email)
+    user && Plausible.Teams.Memberships.site_member?(site, user)
+  end
+
+  defp unsubscribe_link(site, email, interval) do
+    PlausibleWeb.Endpoint.url() <>
+      "/sites/#{URI.encode_www_form(site.domain)}/#{interval}-report/unsubscribe?email=#{email}"
+  end
+
+  defp report_name(@weekly, _), do: "Weekly"
+  defp report_name(@monthly, first), do: Calendar.strftime(first, "%B")
+
+  defp stats(site, date_range) do
+    shared_params = %ParsedQueryParams{
+      metrics: [:visitors],
+      input_date_range: {:date_range, date_range.first, date_range.last},
+      pagination: %{limit: 5, offset: 0}
+    }
+
+    stats = stats_aggregates(site, shared_params)
+    pages = pages(site, shared_params)
+    sources = sources(site, shared_params)
+    goals = goals(site, shared_params)
+
+    stats
+    |> Map.put(:pages, pages)
+    |> Map.put(:sources, sources)
+    |> Map.put(:goals, goals)
+  end
+
+  defp stats_aggregates(site, %ParsedQueryParams{} = shared_params) do
+    query =
+      QueryBuilder.build!(
+        site,
+        struct!(shared_params,
+          metrics: [:pageviews, :visitors, :bounce_rate],
+          include: %QueryInclude{compare: :previous_period}
+        )
+      )
+
+    %QueryResult{
+      results: [
+        %{
+          metrics: [pageviews, visitors, bounce_rate],
+          comparison: %{
+            change: [pageviews_change, visitors_change, bounce_rate_change]
+          }
+        }
+      ]
+    } = Plausible.Stats.query(site, query)
+
+    %{
+      pageviews: %{value: pageviews, change: pageviews_change},
+      visitors: %{value: visitors, change: visitors_change},
+      bounce_rate: %{value: bounce_rate, change: bounce_rate_change}
+    }
+  end
+
+  defp pages(site, %ParsedQueryParams{} = shared_params) do
+    query = QueryBuilder.build!(site, struct!(shared_params, dimensions: ["event:page"]))
+
+    site
+    |> Plausible.Stats.query(query)
+    |> Map.fetch!(:results)
+    |> Enum.map(fn %{metrics: [visitors], dimensions: [page]} ->
+      %{
+        page: page,
+        visitors: visitors
+      }
+    end)
+  end
+
+  defp sources(site, %ParsedQueryParams{} = shared_params) do
+    query =
+      QueryBuilder.build!(
+        site,
+        struct!(shared_params,
+          dimensions: ["visit:source"],
+          filters: [[:is_not, "visit:source", ["Direct / None"]]]
+        )
+      )
+
+    site
+    |> Plausible.Stats.query(query)
+    |> Map.fetch!(:results)
+    |> Enum.map(fn %{metrics: [visitors], dimensions: [source]} ->
+      %{
+        source: source,
+        visitors: visitors
+      }
+    end)
+  end
+
+  defp goals(site, %ParsedQueryParams{} = shared_params) do
+    query = QueryBuilder.build!(site, struct!(shared_params, dimensions: ["event:goal"]))
+
+    site
+    |> Plausible.Stats.query(query)
+    |> Map.fetch!(:results)
+    |> Enum.map(fn %{metrics: [visitors], dimensions: [goal_name]} ->
+      %{
+        goal: goal_name,
+        visitors: visitors
+      }
+    end)
+  end
+
+  defp date_range(site, @weekly) do
+    first =
+      site.timezone
+      |> DateTime.now!()
+      |> Date.shift(day: -7)
+      |> Date.beginning_of_week()
+
+    last =
+      site.timezone
+      |> DateTime.now!()
+      |> DateTime.to_date()
+      |> Date.shift(day: -7)
+      |> Date.end_of_week()
+
+    Date.range(first, last)
+  end
+
+  defp date_range(site, @monthly) do
+    first =
+      site.timezone
+      |> DateTime.now!()
+      |> Date.shift(month: -1)
+      |> Date.beginning_of_month()
+
+    last =
+      site.timezone
+      |> DateTime.now!()
+      |> DateTime.shift(month: -1)
+      |> DateTime.to_date()
+      |> Date.end_of_month()
+
+    Date.range(first, last)
+  end
+
+  on_ee do
+    defp ok_to_send?(site) do
+      Plausible.Sites.regular?(site) or
+        (Plausible.Sites.consolidated?(site) and
+           Plausible.ConsolidatedView.ok_to_display?(site.team))
+    end
+  else
+    defp ok_to_send?(_site), do: always(true)
+  end
+end

lib/workers/send_site_setup_emails.ex

@@ -0,0 +1,121 @@
+defmodule Plausible.Workers.SendSiteSetupEmails do
+  @moduledoc """
+  Job sending site setup emails.
+  """
+
+  use Plausible.Repo
+  use Oban.Worker, queue: :site_setup_emails
+
+  @impl Oban.Worker
+  def perform(_job) do
+    send_create_site_emails()
+    send_setup_help_emails()
+    send_setup_success_emails()
+
+    :ok
+  end
+
+  defp send_create_site_emails() do
+    q =
+      from u in Plausible.Auth.User,
+        as: :user,
+        where:
+          not exists(
+            from tm in Plausible.Teams.Membership,
+              where: tm.user_id == parent_as(:user).id,
+              select: true
+          ),
+        where:
+          not exists(
+            from se in "create_site_emails",
+              where: se.user_id == parent_as(:user).id,
+              select: true
+          ),
+        where:
+          u.inserted_at > fragment("(now() at time zone 'utc') - '72 hours'::interval") and
+            u.inserted_at < fragment("(now() at time zone 'utc') - '48 hours'::interval")
+
+    for user <- Repo.all(q) do
+      send_create_site_email(user)
+    end
+  end
+
+  defp send_setup_help_emails() do
+    q =
+      from(s in Plausible.Site.regular(),
+        left_join: se in "setup_help_emails",
+        on: se.site_id == s.id,
+        where: is_nil(se.id),
+        where: s.inserted_at > fragment("(now() at time zone 'utc') - '72 hours'::interval"),
+        preload: [:owners, :team]
+      )
+
+    for site <- Repo.all(q) do
+      owners = site.owners
+      setup_completed = Plausible.Sites.has_stats?(site)
+      hours_passed = NaiveDateTime.diff(DateTime.utc_now(), site.inserted_at, :hour)
+
+      if !setup_completed && hours_passed > 47 do
+        send_setup_help_email(owners, site)
+      end
+    end
+  end
+
+  defp send_setup_success_emails() do
+    q =
+      from(s in Plausible.Site.regular(),
+        left_join: se in "setup_success_emails",
+        on: se.site_id == s.id,
+        where: is_nil(se.id),
+        inner_join: t in assoc(s, :team),
+        where: s.inserted_at > fragment("(now() at time zone 'utc') - '72 hours'::interval"),
+        preload: [:owners, team: t]
+      )
+
+    for site <- Repo.all(q) do
+      if Plausible.Sites.has_stats?(site) do
+        send_setup_success_email(site)
+      end
+    end
+  end
+
+  defp send_create_site_email(user) do
+    PlausibleWeb.Email.create_site_email(user)
+    |> Plausible.Mailer.send()
+
+    Repo.insert_all("create_site_emails", [
+      %{
+        user_id: user.id,
+        timestamp: NaiveDateTime.utc_now()
+      }
+    ])
+  end
+
+  defp send_setup_success_email(site) do
+    for owner <- site.owners do
+      PlausibleWeb.Email.site_setup_success(owner, site)
+      |> Plausible.Mailer.send()
+    end
+
+    Repo.insert_all("setup_success_emails", [
+      %{
+        site_id: site.id,
+        timestamp: NaiveDateTime.utc_now()
+      }
+    ])
+  end
+
+  defp send_setup_help_email(users, site) do
+    for user <- users do
+      PlausibleWeb.Email.site_setup_help(user, site.team, site)
+      |> Plausible.Mailer.send()
+    end
+
+    Repo.insert_all("setup_help_emails", [
+      %{
+        site_id: site.id,
+        timestamp: NaiveDateTime.utc_now()
+      }
+    ])
+  end
+end

lib/workers/send_trial_notifications.ex

@@ -0,0 +1,85 @@
+defmodule Plausible.Workers.SendTrialNotifications do
+  @moduledoc """
+  Job sending trial end notification emails.
+  """
+  use Plausible.Repo
+
+  use Oban.Worker,
+    queue: :trial_notification_emails,
+    max_attempts: 1
+
+  alias Plausible.Teams
+
+  @impl Oban.Worker
+  def perform(_job) do
+    teams =
+      Repo.all(
+        from t in Teams.Team,
+          inner_join: o in assoc(t, :owners),
+          left_join: bm in assoc(t, :billing_members),
+          left_join: s in assoc(t, :subscription),
+          where: not is_nil(t.trial_expiry_date),
+          where: is_nil(s.id),
+          order_by: t.inserted_at,
+          preload: [owners: o, billing_members: bm]
+      )
+      |> Enum.filter(&Teams.has_active_sites?/1)
+
+    for team <- teams do
+      recipients = team.owners ++ team.billing_members
+
+      case Date.diff(team.trial_expiry_date, Date.utc_today()) do
+        7 ->
+          send_one_week_reminder(recipients, team)
+
+        1 ->
+          send_tomorrow_reminder(recipients, team)
+
+        0 ->
+          send_today_reminder(recipients, team)
+
+        -1 ->
+          send_over_reminder(recipients, team)
+
+        _ ->
+          nil
+      end
+    end
+
+    :ok
+  end
+
+  defp send_one_week_reminder(users, team) do
+    for user <- users do
+      PlausibleWeb.Email.trial_one_week_reminder(user, team)
+      |> Plausible.Mailer.send()
+    end
+  end
+
+  defp send_tomorrow_reminder(users, team) do
+    usage = Plausible.Teams.Billing.usage_cycle(team, :last_30_days)
+    suggested_volume = Plausible.Billing.Plans.suggest_volume(team, usage.total)
+
+    for user <- users do
+      PlausibleWeb.Email.trial_ending_tomorrow_email(user, team, usage, suggested_volume)
+      |> Plausible.Mailer.send()
+    end
+  end
+
+  defp send_today_reminder(users, team) do
+    usage = Plausible.Teams.Billing.usage_cycle(team, :last_30_days)
+    suggested_volume = Plausible.Billing.Plans.suggest_volume(team, usage.total)
+
+    for user <- users do
+      PlausibleWeb.Email.trial_ending_today_email(user, team, usage, suggested_volume)
+      |> Plausible.Mailer.send()
+    end
+  end
+
+  defp send_over_reminder(users, team) do
+    for user <- users do
+      PlausibleWeb.Email.trial_over_email(user, team)
+      |> Plausible.Mailer.send()
+    end
+  end
+end

lib/workers/set_legacy_time_on_page_cutoff.ex

@@ -0,0 +1,96 @@
+defmodule Plausible.Workers.SetLegacyTimeOnPageCutoff do
+  @moduledoc """
+  Sets sites `legacy_time_on_page_cutoff` depending on whether they have
+  sent us engagement data in the past.
+  """
+
+  use Plausible.Repo
+  use Plausible.ClickhouseRepo
+  use Oban.Worker, queue: :legacy_time_on_page_cutoff
+
+  import Ecto.Query
+
+  require Logger
+
+  @impl Oban.Worker
+  def perform(%Oban.Job{args: args}) do
+    cutoff_date = Map.get(args, "cutoff_date", Date.utc_today())
+
+    {small_sites, large_sites} =
+      sites_with_engagement_data(cutoff_date)
+      |> filter_sites_needing_update()
+
+    to_update = small_sites ++ large_sites
+
+    if length(to_update) > 0 do
+      Logger.notice(
+        "Setting legacy_time_on_page_cutoff for #{length(to_update)} sites (#{length(small_sites)} small, #{length(large_sites)} large)"
+      )
+
+      {count, _} =
+        Repo.update_all(
+          from(s in Plausible.Site.regular(),
+            where: s.id in ^to_update,
+            where: is_nil(s.legacy_time_on_page_cutoff)
+          ),
+          set: [legacy_time_on_page_cutoff: cutoff_date]
+        )
+
+      Logger.notice(
+        "Successfully set legacy_time_on_page_cutoff=#{cutoff_date} for #{count} sites"
+      )
+    else
+      Logger.debug("No sites legacy_time_on_page_cutoff needs updating")
+    end
+
+    :ok
+  end
+
+  defp sites_with_engagement_data(cutoff_date) do
+    site_info_q =
+      from(
+        e in "events_v2",
+        where: e.timestamp >= fragment("toStartOfHour(? - toIntervalHour(48))", ^cutoff_date),
+        where: e.timestamp < fragment("toStartOfHour(? - toIntervalHour(24))", ^cutoff_date),
+        group_by: e.site_id,
+        select: %{
+          site_id: e.site_id,
+          hours_with_engagement:
+            fragment(
+              "uniqIf(toStartOfHour(timestamp), name = 'engagement' AND engagement_time > 0)"
+            ),
+          is_small_site: fragment("count() < 2000")
+        }
+      )
+
+    q =
+      from(
+        s in subquery(site_info_q),
+        select: %{
+          small_sites:
+            fragment("groupArrayIf(site_id, (is_small_site and hours_with_engagement > 0))"),
+          large_sites:
+            fragment("groupArrayIf(site_id, (not is_small_site and hours_with_engagement = 24))")
+        }
+      )
+
+    result = ClickhouseRepo.one(q)
+
+    {MapSet.new(result.small_sites), MapSet.new(result.large_sites)}
+  end
+
+  defp filter_sites_needing_update({small_sites, large_sites}) do
+    needing_update =
+      from(s in Plausible.Site.regular(),
+        where: is_nil(s.legacy_time_on_page_cutoff),
+        select: s.id
+      )
+      |> Repo.all()
+      |> MapSet.new()
+
+    {
+      small_sites |> MapSet.intersection(needing_update) |> MapSet.to_list(),
+      large_sites |> MapSet.intersection(needing_update) |> MapSet.to_list()
+    }
+  end
+end

lib/workers/traffic_change_notifier.ex

@@ -0,0 +1,181 @@
+defmodule Plausible.Workers.TrafficChangeNotifier do
+  @moduledoc """
+  Oban service sending out traffic drop/spike notifications
+  """
+  use Plausible
+  use Plausible.Repo
+  alias Plausible.Stats.{Clickhouse, ParsedQueryParams, QueryBuilder}
+  alias Plausible.Site.TrafficChangeNotification
+
+  alias PlausibleWeb.Router.Helpers, as: Routes
+
+  use Oban.Worker, queue: :spike_notifications
+  @min_interval_hours 12
+
+  @impl Oban.Worker
+  def perform(_job, now \\ NaiveDateTime.utc_now(:second)) do
+    today = NaiveDateTime.to_date(now)
+
+    notifications =
+      Repo.all(
+        from sn in TrafficChangeNotification,
+          where:
+            is_nil(sn.last_sent) or
+              sn.last_sent < ^NaiveDateTime.add(now, -@min_interval_hours, :hour),
+          inner_join: s in assoc(sn, :site),
+          inner_join: t in assoc(s, :team),
+          where: not t.locked,
+          where: is_nil(t.accept_traffic_until) or t.accept_traffic_until > ^today,
+          preload: [site: {s, team: t}]
+      )
+
+    for notification <- notifications, ok_to_send?(notification.site) do
+      handle_notification(notification, now)
+    end
+
+    :ok
+  end
+
+  defp handle_notification(%TrafficChangeNotification{type: :spike} = notification, now) do
+    current_visitors = Clickhouse.current_visitors(notification.site)
+
+    if current_visitors >= notification.threshold do
+      stats =
+        notification.site
+        |> get_traffic_spike_stats()
+        |> Map.put(:current_visitors, current_visitors)
+
+      notify_spike(notification, stats, now)
+    end
+  end
+
+  defp handle_notification(%TrafficChangeNotification{type: :drop} = notification, now) do
+    current_visitors = Clickhouse.current_visitors_12h(notification.site)
+
+    if current_visitors < notification.threshold do
+      notify_drop(notification, current_visitors, now)
+    end
+  end
+
+  defp notify_spike(notification, stats, now) do
+    for recipient_email <- notification.recipients do
+      send_spike_notification(recipient_email, notification.site, stats)
+    end
+
+    notification
+    |> TrafficChangeNotification.was_sent(now)
+    |> Repo.update()
+  end
+
+  defp notify_drop(notification, current_visitors, now) do
+    for recipient_email <- notification.recipients do
+      send_drop_notification(recipient_email, notification.site, current_visitors)
+    end
+
+    notification
+    |> TrafficChangeNotification.was_sent(now)
+    |> Repo.update()
+  end
+
+  defp send_spike_notification(recipient_email, site, stats) do
+    dashboard_link =
+      if site_member?(site, recipient_email) do
+        Routes.stats_url(PlausibleWeb.Endpoint, :stats, site.domain, []) <>
+          "?__team=#{site.team.identifier}"
+      end
+
+    template =
+      PlausibleWeb.Email.spike_notification(
+        recipient_email,
+        site,
+        stats,
+        dashboard_link
+      )
+
+    Plausible.Mailer.send(template)
+  end
+
+  defp send_drop_notification(recipient_email, site, current_visitors) do
+    site_member? = site_member?(site, recipient_email)
+
+    dashboard_link =
+      if site_member? do
+        Routes.stats_url(PlausibleWeb.Endpoint, :stats, site.domain, []) <>
+          "?__team=#{site.team.identifier}"
+      end
+
+    installation_link =
+      if site_member? and Plausible.Sites.regular?(site) do
+        Routes.site_url(PlausibleWeb.Endpoint, :installation, site.domain,
+          flow: PlausibleWeb.Flows.review()
+        ) <> "&__team=#{site.team.identifier}"
+      end
+
+    template =
+      PlausibleWeb.Email.drop_notification(
+        recipient_email,
+        site,
+        current_visitors,
+        dashboard_link,
+        installation_link
+      )
+
+    Plausible.Mailer.send(template)
+  end
+
+  defp get_traffic_spike_stats(site) do
+    %{}
+    |> put_sources(site)
+    |> put_pages(site)
+  end
+
+  @base_query_params %ParsedQueryParams{
+    metrics: [:visitors],
+    pagination: %{limit: 3, offset: 0},
+    input_date_range: :realtime
+  }
+
+  defp put_sources(stats, site) do
+    query =
+      QueryBuilder.build!(
+        site,
+        struct!(@base_query_params,
+          dimensions: ["visit:source"],
+          filters: [[:is_not, "visit:source", ["Direct / None"]]]
+        )
+      )
+
+    %{results: sources} = Plausible.Stats.query(site, query)
+
+    Map.put(stats, :sources, sources)
+  end
+
+  defp put_pages(stats, site) do
+    query = QueryBuilder.build!(site, struct!(@base_query_params, dimensions: ["event:page"]))
+
+    %{results: pages} = Plausible.Stats.query(site, query)
+
+    Map.put(stats, :pages, pages)
+  end
+
+  defp site_member?(site, recipient_email) do
+    from(tm in Plausible.Teams.Membership,
+      inner_join: u in assoc(tm, :user),
+      left_join: gm in assoc(tm, :guest_memberships),
+      where: tm.team_id == ^site.team_id,
+      where: tm.role != :guest or gm.site_id == ^site.id,
+      where: u.email == ^recipient_email
+    )
+    |> Repo.exists?()
+  end
+
+  on_ee do
+    defp ok_to_send?(site) do
+      Plausible.Sites.regular?(site) or
+        (Plausible.Sites.consolidated?(site) and
+           Plausible.ConsolidatedView.ok_to_display?(site.team))
+    end
+  else
+    defp ok_to_send?(_site), do: always(true)
+  end
+end

mix.exs

@@ -0,0 +1,246 @@
+defmodule Plausible.MixProject do
+  use Mix.Project
+
+  def project do
+    [
+      name: "Plausible",
+      source_url: "https://github.com/plausible/analytics",
+      docs: docs(),
+      app: :plausible,
+      version: System.get_env("APP_VERSION", "0.0.1"),
+      elixir: "~> 1.18",
+      elixirc_paths: elixirc_paths(Mix.env()),
+      start_permanent: Mix.env() in [:prod, :ce, :load],
+      aliases: aliases(),
+      deps: deps(),
+      test_coverage: [
+        tool: ExCoveralls
+      ],
+      listeners: [Phoenix.CodeReloader],
+      releases: [
+        plausible: [
+          include_executables_for: [:unix],
+          config_providers: [
+            {Config.Reader,
+             path: {:system, "RELEASE_ROOT", "/import_extra_config.exs"}, imports: []}
+          ]
+        ]
+      ],
+      dialyzer: [
+        plt_file: {:no_warn, "priv/plts/dialyzer.plt"},
+        plt_add_apps: [:mix, :ex_unit]
+      ]
+    ]
+  end
+
+  # Configuration for the OTP application.
+  #
+  # Type `mix help compile.app` for more information.
+  def application do
+    [
+      mod: {Plausible.Application, []},
+      extra_applications:
+        [
+          :logger,
+          :runtime_tools,
+          :tls_certificate_check,
+          :opentelemetry_exporter
+        ] ++ if(Mix.env() in [:dev, :load], do: [:tools, :observer, :wx], else: [])
+    ]
+  end
+
+  def cli do
+    [
+      preferred_envs: [
+        "test.e2e": :e2e_test,
+        "test.e2e.ui": :e2e_test
+      ]
+    ]
+  end
+
+  # Specifies which paths to compile per environment.
+  defp elixirc_paths(env) when env in [:test, :e2e_test, :dev],
+    do: ["lib", "test/support", "extra/lib"]
+
+  defp elixirc_paths(env) when env in [:ce_test, :ce_dev],
+    do: ["lib", "test/support"]
+
+  defp elixirc_paths(:ce), do: ["lib"]
+  defp elixirc_paths(_), do: ["lib", "extra/lib"]
+
+  # Specifies your project dependencies.
+  #
+  # Type `mix help deps` for examples and options.
+  defp deps do
+    [
+      {:bamboo, "~> 2.3", override: true},
+      {:bamboo_postmark, git: "https://github.com/plausible/bamboo_postmark.git", branch: "main"},
+      {:bamboo_mua, "~> 0.2.0"},
+      {:bcrypt_elixir, "~> 3.3"},
+      {:bypass, "~> 2.1", only: [:dev, :test, :ce_test, :e2e_test]},
+      {:ecto_ch, "~> 0.8.6"},
+      {:cloak, "~> 1.1"},
+      {:cloak_ecto, "~> 1.2"},
+      {:combination, "~> 0.0.3"},
+      {:cors_plug, "~> 3.0"},
+      {:credo, "~> 1.7", only: [:dev, :test], runtime: false},
+      {:dialyxir, "~> 1.4", only: [:dev, :test], runtime: false},
+      {:double, "~> 0.8.0", only: [:dev, :test, :ce_test, :ce_dev, :e2e_test]},
+      {:ecto, "~> 3.13.5"},
+      {:ecto_sql, "~> 3.13.2"},
+      {:envy, "~> 1.1.1"},
+      {:eqrcode, "~> 0.2.1"},
+      {:ex_machina, "~> 2.3", only: [:dev, :test, :ce_dev, :ce_test, :e2e_test]},
+      {:excoveralls, "~> 0.10", only: :test},
+      {:finch, "~> 0.23"},
+      {:lazy_html, "~> 0.1.8"},
+      {:fun_with_flags, "~> 1.13.0"},
+      {:fun_with_flags_ui, "~> 1.0"},
+      {:locus, "~> 2.3"},
+      {:gen_cycle, "~> 1.0.4"},
+      {:hackney, "~> 1.8"},
+      {:jason, "~> 1.3"},
+      {:location, git: "https://github.com/plausible/location.git"},
+      {:mox, "~> 1.0", only: [:test, :ce_test, :e2e_test]},
+      {:nanoid, "~> 2.1.0"},
+      {:nimble_totp, "~> 1.0"},
+      {:oban, "~> 2.20.1"},
+      {:observer_cli, "~> 1.7"},
+      {:opentelemetry, "~> 1.7"},
+      {:opentelemetry_api, "~> 1.5"},
+      {:opentelemetry_api_experimental,
+       git: "https://github.com/open-telemetry/opentelemetry-erlang.git",
+       ref: "b241ebf4feb7558738d009583bae8602b3c49fd0",
+       sparse: "apps/opentelemetry_api_experimental",
+       override: true},
+      {:opentelemetry_ecto, "~> 1.2"},
+      {:opentelemetry_exporter, "~> 1.10"},
+      {:opentelemetry_experimental,
+       git: "https://github.com/open-telemetry/opentelemetry-erlang.git",
+       ref: "b241ebf4feb7558738d009583bae8602b3c49fd0",
+       sparse: "apps/opentelemetry_experimental",
+       override: true},
+      {:opentelemetry_phoenix, "~> 2.0.1"},
+      {:opentelemetry_oban, "~> 1.1"},
+      {:opentelemetry_cowboy, "~> 1.0"},
+      # # https://github.com/open-telemetry/opentelemetry-erlang-contrib/issues/428
+      {:opentelemetry_semantic_conventions, "~> 1.27", override: true},
+      {:phoenix, "~> 1.8.2"},
+      {:phoenix_view, "~> 2.0"},
+      {:phoenix_ecto, "~> 4.5"},
+      {:phoenix_html, "~> 4.1"},
+      {:phoenix_live_reload, "~> 1.2", only: [:dev, :ce_dev]},
+      {:phoenix_pubsub, "~> 2.0"},
+      {:phoenix_live_view, "~> 1.1.17"},
+      {:php_serializer, "~> 2.0"},
+      {:plug, "~> 1.13", override: true},
+      {:prima, "~> 0.2.6"},
+      {:plug_cowboy, "~> 2.3"},
+      {:polymorphic_embed, "~> 5.0"},
+      {:postgrex, "~> 0.22.2"},
+      {:prom_ex, "~> 1.8"},
+      {:peep, "~> 3.0"},
+      {:public_suffix, git: "https://github.com/axelson/publicsuffix-elixir"},
+      {:recon, "~> 2.5"},
+      {:ref_inspector, "~> 2.0"},
+      {:referrer_blocklist, git: "https://github.com/plausible/referrer-blocklist.git"},
+      {:sentry, "~> 11.0.4"},
+      {:simple_saml, "~> 1.2"},
+      {:xml_builder, "~> 2.1"},
+      {:siphash, "~> 3.2"},
+      {:timex, "~> 3.7"},
+      {:ua_inspector, "~> 3.12"},
+      {:ex_doc, "~> 0.28", only: :dev, runtime: false},
+      {:ex_money, "~> 5.24.2"},
+      {:mjml_eex, "~> 0.12.0"},
+      {:mjml, "~> 4.0.0"},
+      {:heroicons, "~> 0.5.0"},
+      {:zxcvbn, git: "https://github.com/techgaun/zxcvbn-elixir.git"},
+      {:open_api_spex, "~> 3.22.1"},
+      {:joken, "~> 2.5"},
+      {:paginator, git: "https://github.com/duffelhq/paginator.git"},
+      {:esbuild, "~> 0.7", runtime: Mix.env() in [:dev, :ce_dev]},
+      {:tailwind, "~> 0.4.0", runtime: Mix.env() in [:dev, :ce_dev]},
+      {:ex_json_logger, "~> 1.4.0"},
+      {:ecto_network, "~> 1.6.0"},
+      {:ex_aws, "~> 2.5"},
+      {:ex_aws_s3, "~> 2.5"},
+      {:sweet_xml, "~> 0.7.4"},
+      {:zstream, "~> 0.6.4"},
+      {:con_cache,
+       git: "https://github.com/aerosol/con_cache", branch: "ensure-dirty-ops-emit-telemetry"},
+      {:req, "~> 0.6"},
+      {:opentelemetry_req, "~> 1.0"},
+      {:happy_tcp, github: "ruslandoga/happy_tcp", only: [:ce, :ce_dev, :ce_test, :e2e_test]},
+      {:ex_json_schema, "~> 0.11.1"},
+      {:odgn_json_pointer, "~> 3.1.0"},
+      {:phoenix_bakery, "~> 0.1.2", only: [:ce, :ce_dev, :ce_test, :e2e_test]},
+      {:site_encrypt, github: "sasa1977/site_encrypt", only: [:ce, :ce_dev, :ce_test, :e2e_test]},
+      {:phoenix_html_helpers, "~> 1.0"},
+      {:libcluster, "~> 3.5"},
+      {:decimal, "~> 3.0", override: true},
+      {:logger_backends, "~> 1.0.0"}
+    ]
+  end
+
+  defp aliases do
+    [
+      setup: ["deps.get", "ecto.setup", "assets.setup", "assets.build"],
+      "ecto.setup": ["ecto.create", "ecto.migrate", "run priv/repo/seeds.exs"],
+      "ecto.reset": ["ecto.drop", "ecto.setup"],
+      test: ["ecto.create --quiet", "ecto.migrate", "test", "clean_clickhouse"],
+      "e2e.setup": [
+        "cmd npm install --prefix ./e2e",
+        "cmd npm exec playwright install --with-deps chromium --prefix ./e2e"
+      ],
+      # accepts Playwright CLI arguments (https://playwright.dev/docs/test-cli), for example
+      # mix test.e2e --ui
+      # mix test.e2e --debug segments.spec.ts
+      "test.e2e": [
+        "esbuild default",
+        "ecto.create --quiet",
+        "ecto.migrate",
+        "clean_postgres",
+        "clean_clickhouse",
+        "cmd npm run --prefix ./e2e test -- "
+      ],
+      "assets.setup": ["tailwind.install --if-missing", "esbuild.install --if-missing"],
+      "assets.typecheck": ["cmd npm --prefix assets run typecheck"],
+      "assets.build": [
+        "tailwind default",
+        "esbuild default"
+      ],
+      "assets.deploy": [
+        "tailwind default --minify",
+        "esbuild default --minify",
+        "phx.digest"
+      ]
+    ]
+  end
+
+  defp docs do
+    [
+      main: "readme",
+      logo: "priv/static/images/ee/favicon-32x32.png",
+      extras:
+        Path.wildcard("guides/**/*.md") ++
+          [
+            "README.md": [filename: "readme", title: "Introduction"],
+            "CONTRIBUTING.md": [filename: "contributing", title: "Contributing"]
+          ],
+      groups_for_extras: [
+        Features: Path.wildcard("guides/features/*.md")
+      ],
+      before_closing_body_tag: fn
+        :html ->
+          """
+          <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
+          <script>mermaid.initialize({startOnLoad: true})</script>
+          """
+
+        _ ->
+          ""
+      end
+    ]
+  end
+end

mix.lock

@@ -0,0 +1,171 @@
+%{
+  "acceptor_pool": {:hex, :acceptor_pool, "1.0.0", "43c20d2acae35f0c2bcd64f9d2bde267e459f0f3fd23dab26485bf518c281b21", [:rebar3], [], "hexpm", "0cbcd83fdc8b9ad2eee2067ef8b91a14858a5883cb7cd800e6fcd5803e158788"},
+  "attrs": {:hex, :attrs, "0.6.0", "25d738b47829f964a786ef73897d2550b66f3e7d1d7c49a83bc8fd81c71bed93", [:mix], [], "hexpm", "9c30ac15255c2ba8399263db55ba32c2f4e5ec267b654ce23df99168b405c82e"},
+  "bamboo": {:hex, :bamboo, "2.5.0", "973f5cb1471a1d2d7d9da7b8e4f6096afb6a133f85394631184fd40be8adb8ab", [:mix], [{:hackney, ">= 1.15.2", [hex: :hackney, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:mime, "~> 1.4 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "35c8635ff6677a81ab7258944ff15739280f3254a041b6f0229dddeb9b90ad3d"},
+  "bamboo_mua": {:hex, :bamboo_mua, "0.2.4", "1143cb64e0455bd496d4da14132308d1e44a825c2ba5e295c6c2adc33dff3af0", [:mix], [{:bamboo, "~> 2.0", [hex: :bamboo, repo: "hexpm", optional: false]}, {:mail, "~> 0.4.0", [hex: :mail, repo: "hexpm", optional: false]}, {:mua, "~> 0.2.3", [hex: :mua, repo: "hexpm", optional: false]}], "hexpm", "6802c491f8585b047d7f75f0d57f44398b44d105614115a3346710c2de75cc1f"},
+  "bamboo_postmark": {:git, "https://github.com/plausible/bamboo_postmark.git", "c6a773d1b7a4e5c9ec802ace64b5bb526504c25a", [branch: "main"]},
+  "bcrypt_elixir": {:hex, :bcrypt_elixir, "3.3.2", "d50091e3c9492d73e17fc1e1619a9b09d6a5ef99160eb4d736926fd475a16ca3", [:make, :mix], [{:comeonin, "~> 5.3", [hex: :comeonin, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.6", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "471be5151874ae7931911057d1467d908955f93554f7a6cd1b7d804cac8cef53"},
+  "bunt": {:hex, :bunt, "1.0.0", "081c2c665f086849e6d57900292b3a161727ab40431219529f13c4ddcf3e7a44", [:mix], [], "hexpm", "dc5f86aa08a5f6fa6b8096f0735c4e76d54ae5c9fa2c143e5a1fc7c1cd9bb6b5"},
+  "bypass": {:hex, :bypass, "2.1.0", "909782781bf8e20ee86a9cabde36b259d44af8b9f38756173e8f5e2e1fabb9b1", [:mix], [{:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: false]}, {:ranch, "~> 1.3", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "d9b5df8fa5b7a6efa08384e9bbecfe4ce61c77d28a4282f79e02f1ef78d96b80"},
+  "castore": {:hex, :castore, "1.0.19", "6903cabdfd9d1af46454126e7c8385186659dd33ecfb74a885cae52221ad6109", [:mix], [], "hexpm", "3669e6cab13f54c2df26b3e6833745d647f35b6e30d8ddd5975df0d5c842ca98"},
+  "cc_precompiler": {:hex, :cc_precompiler, "0.1.11", "8c844d0b9fb98a3edea067f94f616b3f6b29b959b6b3bf25fee94ffe34364768", [:mix], [{:elixir_make, "~> 0.7", [hex: :elixir_make, repo: "hexpm", optional: false]}], "hexpm", "3427232caf0835f94680e5bcf082408a70b48ad68a5f5c0b02a3bea9f3a075b9"},
+  "certifi": {:hex, :certifi, "2.15.0", "0e6e882fcdaaa0a5a9f2b3db55b1394dba07e8d6d9bcad08318fb604c6839712", [:rebar3], [], "hexpm", "b147ed22ce71d72eafdad94f055165c1c182f61a2ff49df28bcc71d1d5b94a60"},
+  "ch": {:hex, :ch, "0.7.1", "116c08094b30d095c3bd6a8fe4ebe19fdaaf3dce84e2413cfdd6af157baf6303", [:mix], [{:db_connection, "~> 2.9.0", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:ecto, "~> 3.13.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mint, "~> 1.0", [hex: :mint, repo: "hexpm", optional: false]}], "hexpm", "3c1c900291ff9c4c077cd1dc0c265051a3f1d26320d58b37ed9e91b33d41a868"},
+  "chatterbox": {:hex, :ts_chatterbox, "0.15.1", "5cac4d15dd7ad61fc3c4415ce4826fc563d4643dee897a558ec4ea0b1c835c9c", [:rebar3], [{:hpack, "~> 0.3.0", [hex: :hpack_erl, repo: "hexpm", optional: false]}], "hexpm", "4f75b91451338bc0da5f52f3480fa6ef6e3a2aeecfc33686d6b3d0a0948f31aa"},
+  "cldr_utils": {:hex, :cldr_utils, "2.29.7", "2189bc0117efe91c684558e79174b45eb43135595b7d1fe9b57f53917be195c1", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:certifi, "~> 2.5", [hex: :certifi, repo: "hexpm", optional: true]}, {:decimal, "~> 1.9 or ~> 2.0 or ~> 3.0", [hex: :decimal, repo: "hexpm", optional: false]}], "hexpm", "4bddcd597fee34e2d2829ae9ef62bcfef8d97ae5f6b75f0c6ee37a3db31aa73a"},
+  "cloak": {:hex, :cloak, "1.1.4", "aba387b22ea4d80d92d38ab1890cc528b06e0e7ef2a4581d71c3fdad59e997e7", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "92b20527b9aba3d939fab0dd32ce592ff86361547cfdc87d74edce6f980eb3d7"},
+  "cloak_ecto": {:hex, :cloak_ecto, "1.3.0", "0de127c857d7452ba3c3367f53fb814b0410ff9c680a8d20fbe8b9a3c57a1118", [:mix], [{:cloak, "~> 1.1.1", [hex: :cloak, repo: "hexpm", optional: false]}, {:ecto, "~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}], "hexpm", "314beb0c123b8a800418ca1d51065b27ba3b15f085977e65c0f7b2adab2de1cc"},
+  "combination": {:hex, :combination, "0.0.3", "746aedca63d833293ec6e835aa1f34974868829b1486b1e1cb0685f0b2ae1f41", [:mix], [], "hexpm", "72b099f463df42ef7dc6371d250c7070b57b6c5902853f69deb894f79eda18ca"},
+  "combine": {:hex, :combine, "0.10.0", "eff8224eeb56498a2af13011d142c5e7997a80c8f5b97c499f84c841032e429f", [:mix], [], "hexpm", "1b1dbc1790073076580d0d1d64e42eae2366583e7aecd455d1215b0d16f2451b"},
+  "comeonin": {:hex, :comeonin, "5.5.1", "5113e5f3800799787de08a6e0db307133850e635d34e9fab23c70b6501669510", [:mix], [], "hexpm", "65aac8f19938145377cee73973f192c5645873dcf550a8a6b18187d17c13ccdb"},
+  "con_cache": {:git, "https://github.com/aerosol/con_cache", "d050e133742e512cf2caa4598607e60dd0161072", [branch: "ensure-dirty-ops-emit-telemetry"]},
+  "cors_plug": {:hex, :cors_plug, "3.0.3", "7c3ac52b39624bc616db2e937c282f3f623f25f8d550068b6710e58d04a0e330", [:mix], [{:plug, "~> 1.13", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "3f2d759e8c272ed3835fab2ef11b46bddab8c1ab9528167bd463b6452edf830d"},
+  "cowboy": {:hex, :cowboy, "2.16.1", "fa04080b602ff25c40a7700f2dc0152dbc1ba26b42093ae0fa9bb7a337d5a242", [:make, :rebar3], [{:cowlib, ">= 2.16.0 and < 3.0.0", [hex: :cowlib, repo: "hexpm", optional: false]}, {:ranch, ">= 1.8.0 and < 3.0.0", [hex: :ranch, repo: "hexpm", optional: false]}], "hexpm", "b8ea4dd317a043e3177ec840cfa3bcb47cfb41035d3abb24d954dc7d51def399"},
+  "cowboy_telemetry": {:hex, :cowboy_telemetry, "0.4.0", "f239f68b588efa7707abce16a84d0d2acf3a0f50571f8bb7f56a15865aae820c", [:rebar3], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7d98bac1ee4565d31b62d59f8823dfd8356a169e7fcbb83831b8a5397404c9de"},
+  "cowlib": {:hex, :cowlib, "2.18.0", "4a3ef8cb012c21c7cbb7c925f75405e26d7fcd393fd78c46187539dbc9a48310", [:make, :rebar3], [], "hexpm", "c4f89d33a61162d4cfdcb5a1af7e562d80a700b2573cc71020ce6521b152dc1a"},
+  "credo": {:hex, :credo, "1.7.19", "cc52129665fc7c15143d47838fda0f9cd6dac9ceced7bf4da6f85fcbfe64b12a", [:mix], [{:bunt, "~> 0.2.1 or ~> 1.0", [hex: :bunt, repo: "hexpm", optional: false]}, {:file_system, "~> 0.2 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "2d8bc95d5a7bb99dd2613621d4f08c6a3575c3fd4b62e6a2b48a100352a557b8"},
+  "ctx": {:hex, :ctx, "0.6.0", "8ff88b70e6400c4df90142e7f130625b82086077a45364a78d208ed3ed53c7fe", [:rebar3], [], "hexpm", "a14ed2d1b67723dbebbe423b28d7615eb0bdcba6ff28f2d1f1b0a7e1d4aa5fc2"},
+  "db_connection": {:hex, :db_connection, "2.9.0", "a6a97c5c958a2d7091a58a9be40caf41ab496b0701d21e1d1abff3fa27a7f371", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "17d502eacaf61829db98facf6f20808ed33da6ccf495354a41e64fe42f9c509c"},
+  "decimal": {:hex, :decimal, "3.1.1", "430d87b04011ce6cbd4fd205be758311a81f87d552d40904abd00f015935b1d0", [:mix], [], "hexpm", "c5f25f2ced74a0587d03e6023f595db8e924c9d3922c8c8ffd9edfc4498cf1f6"},
+  "dialyxir": {:hex, :dialyxir, "1.4.7", "dda948fcee52962e4b6c5b4b16b2d8fa7d50d8645bbae8b8685c3f9ecb7f5f4d", [:mix], [{:erlex, ">= 0.2.8", [hex: :erlex, repo: "hexpm", optional: false]}], "hexpm", "b34527202e6eb8cee198efec110996c25c5898f43a4094df157f8d28f27d9efe"},
+  "digital_token": {:hex, :digital_token, "2.0.0", "fb3c74411790994895c4a61387ab322b64a682995ef2f54a4627c92d46be5d62", [:mix], [], "hexpm", "cbd2fff52770284a8251540a4b4e529e9738c6fe052d7f3c3428eb5c817385cd"},
+  "double": {:hex, :double, "0.8.2", "8e1cfcccdaef76c18846bc08e555555a2a699b806fa207b6468572a60513cc6a", [:mix], [], "hexpm", "90287642b2ec86125e0457aaba2ab0e80f7d7050cc80a0cef733e59bd70aa67c"},
+  "earmark_parser": {:hex, :earmark_parser, "1.4.41", "ab34711c9dc6212dda44fcd20ecb87ac3f3fce6f0ca2f28d4a00e4154f8cd599", [:mix], [], "hexpm", "a81a04c7e34b6617c2792e291b5a2e57ab316365c2644ddc553bb9ed863ebefa"},
+  "ecto": {:hex, :ecto, "3.13.6", "352135b474f91d1ab99a1b502171d207e9db60421c9e3d0ecab4c7ab96b24d14", [:mix], [{:decimal, "~> 2.0 or ~> 3.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "8afa059bc16cd2c94739ec0a11e3e5df69d828125119109bef35f20a21a76af2"},
+  "ecto_ch": {:hex, :ecto_ch, "0.8.6", "f31b507e86690c003f46e75d6e742e6b5d8ce34b6b10a86604b1c3aa785e0b56", [:mix], [{:ch, "~> 0.5.0 or ~> 0.6.0 or ~> 0.7.0", [hex: :ch, repo: "hexpm", optional: false]}, {:ecto_sql, "~> 3.13.0", [hex: :ecto_sql, repo: "hexpm", optional: false]}], "hexpm", "6ca9f1cf9680452b1925c6a3a7b5e3d8b12e38ee134b03c6a45a8b26434fad97"},
+  "ecto_network": {:hex, :ecto_network, "1.6.0", "f3159c0adb280321b72dc711b3fc7bcc48e2772f71db292a1c3529c587603611", [:mix], [{:ecto_sql, ">= 3.0.0", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:phoenix_html, ">= 0.0.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:postgrex, ">= 0.14.0", [hex: :postgrex, repo: "hexpm", optional: false]}], "hexpm", "000411a6d3a585845f6809383f20afd418c090e104f862241124ac9518ac1073"},
+  "ecto_sql": {:hex, :ecto_sql, "3.13.4", "b6e9d07557ddba62508a9ce4a484989a5bb5e9a048ae0e695f6d93f095c25d60", [:mix], [{:db_connection, "~> 2.4.1 or ~> 2.5", [hex: :db_connection, repo: "hexpm", optional: false]}, {:ecto, "~> 3.13.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:myxql, "~> 0.7", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.19 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}, {:tds, "~> 2.1.1 or ~> 2.2", [hex: :tds, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.0 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "2b38cf0749ca4d1c5a8bcbff79bbe15446861ca12a61f9fba604486cb6b62a14"},
+  "elixir_make": {:hex, :elixir_make, "0.9.0", "6484b3cd8c0cee58f09f05ecaf1a140a8c97670671a6a0e7ab4dc326c3109726", [:mix], [], "hexpm", "db23d4fd8b757462ad02f8aa73431a426fe6671c80b200d9710caf3d1dd0ffdb"},
+  "envy": {:hex, :envy, "1.1.1", "0bc9bd654dec24fcdf203f7c5aa1b8f30620f12cfb28c589d5e9c38fe1b07475", [:mix], [], "hexpm", "7061eb1a47415fd757145d8dec10dc0b1e48344960265cb108f194c4252c3a89"},
+  "eqrcode": {:hex, :eqrcode, "0.2.1", "d12838813e8fc87b8940cc05f9baadb189031f6009facdc56ff074375ec73b6e", [:mix], [], "hexpm", "d5828a222b904c68360e7dc2a40c3ef33a1328b7c074583898040f389f928025"},
+  "erlex": {:hex, :erlex, "0.2.8", "cd8116f20f3c0afe376d1e8d1f0ae2452337729f68be016ea544a72f767d9c12", [:mix], [], "hexpm", "9d66ff9fedf69e49dc3fd12831e12a8a37b76f8651dd21cd45fcf5561a8a7590"},
+  "esbuild": {:hex, :esbuild, "0.10.0", "b0aa3388a1c23e727c5a3e7427c932d89ee791746b0081bbe56103e9ef3d291f", [:mix], [{:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "468489cda427b974a7cc9f03ace55368a83e1a7be12fba7e30969af78e5f8c70"},
+  "ex_aws": {:hex, :ex_aws, "2.5.1", "7418917974ea42e9e84b25e88b9f3d21a861d5f953ad453e212f48e593d8d39f", [:mix], [{:configparser_ex, "~> 4.0", [hex: :configparser_ex, repo: "hexpm", optional: true]}, {:hackney, "~> 1.16", [hex: :hackney, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: true]}, {:jsx, "~> 2.8 or ~> 3.0", [hex: :jsx, repo: "hexpm", optional: true]}, {:mime, "~> 1.2 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:sweet_xml, "~> 0.7", [hex: :sweet_xml, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "1b95431f70c446fa1871f0eb9b183043c5a625f75f9948a42d25f43ae2eff12b"},
+  "ex_aws_s3": {:hex, :ex_aws_s3, "2.5.3", "422468e5c3e1a4da5298e66c3468b465cfd354b842e512cb1f6fbbe4e2f5bdaf", [:mix], [{:ex_aws, "~> 2.0", [hex: :ex_aws, repo: "hexpm", optional: false]}, {:sweet_xml, ">= 0.0.0", [hex: :sweet_xml, repo: "hexpm", optional: true]}], "hexpm", "4f09dd372cc386550e484808c5ac5027766c8d0cd8271ccc578b82ee6ef4f3b8"},
+  "ex_cldr": {:hex, :ex_cldr, "2.47.4", "64e1efda73d6c5fa0342d5b6554f39b740fa02ed540dc03997facf573101ad9e", [:mix], [{:cldr_utils, "~> 2.29", [hex: :cldr_utils, repo: "hexpm", optional: false]}, {:decimal, "~> 1.6 or ~> 2.0 or ~> 3.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:gettext, "~> 0.19 or ~> 1.0", [hex: :gettext, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:nimble_parsec, "~> 0.5 or ~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: true]}], "hexpm", "918aabc032955f3eac70abbdf2c5469433132edfaaaccee55451f074ee1ccdba"},
+  "ex_cldr_currencies": {:hex, :ex_cldr_currencies, "2.17.2", "4892b5255a205e8133297b702abbe13c9b51d0281fa8c2ea100f51df9657c3c7", [:mix], [{:ex_cldr, "~> 2.38", [hex: :ex_cldr, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "797095c106a2fe6632981531e29cfb1d2f8ee7de626f4d6243f974d6f74a0112"},
+  "ex_cldr_numbers": {:hex, :ex_cldr_numbers, "2.38.3", "64a99531df09397174b7f477785c43016f223d01856725b541a19d36b8149523", [:mix], [{:decimal, "~> 1.6 or ~> 2.0 or ~> 3.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:digital_token, "~> 1.0 or ~> 2.0", [hex: :digital_token, repo: "hexpm", optional: false]}, {:ex_cldr, "~> 2.45", [hex: :ex_cldr, repo: "hexpm", optional: false]}, {:ex_cldr_currencies, "~> 2.17", [hex: :ex_cldr_currencies, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}], "hexpm", "3a0d87ef2747c66d78ae8967023d415d3d76aa310981047ad601e3287e8fe73c"},
+  "ex_doc": {:hex, :ex_doc, "0.35.1", "de804c590d3df2d9d5b8aec77d758b00c814b356119b3d4455e4b8a8687aecaf", [:mix], [{:earmark_parser, "~> 1.4.39", [hex: :earmark_parser, repo: "hexpm", optional: false]}, {:makeup_c, ">= 0.1.0", [hex: :makeup_c, repo: "hexpm", optional: true]}, {:makeup_elixir, "~> 0.14 or ~> 1.0", [hex: :makeup_elixir, repo: "hexpm", optional: false]}, {:makeup_erlang, "~> 0.1 or ~> 1.0", [hex: :makeup_erlang, repo: "hexpm", optional: false]}, {:makeup_html, ">= 0.1.0", [hex: :makeup_html, repo: "hexpm", optional: true]}], "hexpm", "2121c6402c8d44b05622677b761371a759143b958c6c19f6558ff64d0aed40df"},
+  "ex_json_logger": {:hex, :ex_json_logger, "1.4.0", "ad1dcc1cfe6940ee1d9d489b20757c89769626ce34c4957548d6fbe155cd96f1", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "7548a1ecba290746e06214d2b3d8783c76760c779a8903a8e44bfd23a7340444"},
+  "ex_json_schema": {:hex, :ex_json_schema, "0.11.1", "b593f92937a095f66054bb318681397dfe7304e7d2b6b1a7534ea3aa40024f8c", [:mix], [{:decimal, "~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}], "hexpm", "32d651a575a6ce2fd613f140b0fef8dd0acc7cf8e8bcd29a3a1be5c945700dd5"},
+  "ex_machina": {:hex, :ex_machina, "2.7.0", "b792cc3127fd0680fecdb6299235b4727a4944a09ff0fa904cc639272cd92dc7", [:mix], [{:ecto, "~> 2.2 or ~> 3.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:ecto_sql, "~> 3.0", [hex: :ecto_sql, repo: "hexpm", optional: true]}], "hexpm", "419aa7a39bde11894c87a615c4ecaa52d8f107bbdd81d810465186f783245bf8"},
+  "ex_money": {:hex, :ex_money, "5.24.2", "131eda8a404b654dbf787ca71a8b782e11112e64726d85c27540856f94d4aee5", [:mix], [{:decimal, "~> 1.6 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:ex_cldr, "~> 2.46", [hex: :ex_cldr, repo: "hexpm", optional: false]}, {:ex_cldr_numbers, "~> 2.38", [hex: :ex_cldr_numbers, repo: "hexpm", optional: false]}, {:ex_cldr_units, "~> 3.19", [hex: :ex_cldr_units, repo: "hexpm", optional: true]}, {:gringotts, "~> 1.1", [hex: :gringotts, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:nimble_parsec, "~> 0.5 or ~> 1.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.0 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:poison, "~> 3.0 or ~> 4.0 or ~> 5.0 or ~> 6.0", [hex: :poison, repo: "hexpm", optional: true]}], "hexpm", "707bf02c99537d6cd93e5e5fd7f4faedde3ea2a7a932032b48e5ba0173307920"},
+  "excoveralls": {:hex, :excoveralls, "0.18.0", "b92497e69465dc51bc37a6422226ee690ab437e4c06877e836f1c18daeb35da9", [:mix], [{:castore, "~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}], "hexpm", "1109bb911f3cb583401760be49c02cbbd16aed66ea9509fc5479335d284da60b"},
+  "expo": {:hex, :expo, "1.1.1", "4202e1d2ca6e2b3b63e02f69cfe0a404f77702b041d02b58597c00992b601db5", [:mix], [], "hexpm", "5fb308b9cb359ae200b7e23d37c76978673aa1b06e2b3075d814ce12c5811640"},
+  "file_system": {:hex, :file_system, "1.1.1", "31864f4685b0148f25bd3fbef2b1228457c0c89024ad67f7a81a3ffbc0bbad3a", [:mix], [], "hexpm", "7a15ff97dfe526aeefb090a7a9d3d03aa907e100e262a0f8f7746b78f8f87a5d"},
+  "finch": {:hex, :finch, "0.23.0", "e3f9287ac25a8832f848b144c2b57346aac65b205e2e0629a52adfe6507fd837", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:mint, "~> 1.8", [hex: :mint, repo: "hexpm", optional: false]}, {:nimble_options, "~> 0.4 or ~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_pool, "~> 1.1", [hex: :nimble_pool, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "80e58d3f936f57e3fdf404f83a3642897ae6d9fb642934e46da4d8fe761b99d5"},
+  "fine": {:hex, :fine, "0.1.4", "b19a89c1476c7c57afb5f9314aed5960b5bc95d5277de4cb5ee8e1d1616ce379", [:mix], [], "hexpm", "be3324cc454a42d80951cf6023b9954e9ff27c6daa255483b3e8d608670303f5"},
+  "fun_with_flags": {:hex, :fun_with_flags, "1.13.0", "8e8eddd6b723691211387923b160bc779fa593f59485209a058c90ea4bbb1cd5", [:mix], [{:ecto_sql, "~> 3.0", [hex: :ecto_sql, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.0", [hex: :phoenix_pubsub, repo: "hexpm", optional: true]}, {:redix, "~> 1.0", [hex: :redix, repo: "hexpm", optional: true]}, {:telemetry, "~> 1.3", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "dbbbff607e6f096d3857c88530d1a4e178d9eeec5dc00118e2cc1d076578710a"},
+  "fun_with_flags_ui": {:hex, :fun_with_flags_ui, "1.1.0", "61a394cd7d80c09943a4b02e07c9ab8899781f3392a157b45527d22731bf871a", [:mix], [{:cowboy, ">= 2.0.0", [hex: :cowboy, repo: "hexpm", optional: true]}, {:fun_with_flags, "~> 1.12", [hex: :fun_with_flags, repo: "hexpm", optional: false]}, {:plug, "~> 1.12", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, ">= 2.0.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}], "hexpm", "99b578a250141537ff7774abb832427f3406a4faff3cfc4f074788beeef38f5d"},
+  "gen_cycle": {:hex, :gen_cycle, "1.0.4", "2315199f1256116328fad6a9d4371c2fb0bc39c7f5111b88d2de582300c931cc", [:rebar3], [], "hexpm", "67817e31b352bb00715f80a5571b3c069e26e994b2ebafa376acf76a2d0f66d8"},
+  "gettext": {:hex, :gettext, "0.26.2", "5978aa7b21fada6deabf1f6341ddba50bc69c999e812211903b169799208f2a8", [:mix], [{:expo, "~> 0.5.1 or ~> 1.0", [hex: :expo, repo: "hexpm", optional: false]}], "hexpm", "aa978504bcf76511efdc22d580ba08e2279caab1066b76bb9aa81c4a1e0a32a5"},
+  "gproc": {:hex, :gproc, "0.9.1", "f1df0364423539cf0b80e8201c8b1839e229e5f9b3ccb944c5834626998f5b8c", [:rebar3], [], "hexpm", "905088e32e72127ed9466f0bac0d8e65704ca5e73ee5a62cb073c3117916d507"},
+  "grpcbox": {:hex, :grpcbox, "0.17.1", "6e040ab3ef16fe699ffb513b0ef8e2e896da7b18931a1ef817143037c454bcce", [:rebar3], [{:acceptor_pool, "~> 1.0.0", [hex: :acceptor_pool, repo: "hexpm", optional: false]}, {:chatterbox, "~> 0.15.1", [hex: :ts_chatterbox, repo: "hexpm", optional: false]}, {:ctx, "~> 0.6.0", [hex: :ctx, repo: "hexpm", optional: false]}, {:gproc, "~> 0.9.1", [hex: :gproc, repo: "hexpm", optional: false]}], "hexpm", "4a3b5d7111daabc569dc9cbd9b202a3237d81c80bf97212fbc676832cb0ceb17"},
+  "hackney": {:hex, :hackney, "1.25.0", "390e9b83f31e5b325b9f43b76e1a785cbdb69b5b6cd4e079aa67835ded046867", [:rebar3], [{:certifi, "~> 2.15.0", [hex: :certifi, repo: "hexpm", optional: false]}, {:idna, "~> 6.1.0", [hex: :idna, repo: "hexpm", optional: false]}, {:metrics, "~> 1.0.0", [hex: :metrics, repo: "hexpm", optional: false]}, {:mimerl, "~> 1.4", [hex: :mimerl, repo: "hexpm", optional: false]}, {:parse_trans, "3.4.1", [hex: :parse_trans, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~> 1.1.0", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}, {:unicode_util_compat, "~> 0.7.1", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "7209bfd75fd1f42467211ff8f59ea74d6f2a9e81cbcee95a56711ee79fd6b1d4"},
+  "happy_tcp": {:git, "https://github.com/ruslandoga/happy_tcp.git", "d639436bf8e7b456abc86bac13b722a2b6d60725", []},
+  "heroicons": {:hex, :heroicons, "0.5.6", "95d730e7179c633df32d95c1fdaaecdf81b0da11010b89b737b843ac176a7eb5", [:mix], [{:castore, ">= 0.0.0", [hex: :castore, repo: "hexpm", optional: false]}, {:phoenix_live_view, ">= 0.18.2", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}], "hexpm", "ca267f02a5fa695a4178a737b649fb6644a2e399639d4ba7964c18e8a58c2352"},
+  "hpack": {:hex, :hpack_erl, "0.3.0", "2461899cc4ab6a0ef8e970c1661c5fc6a52d3c25580bc6dd204f84ce94669926", [:rebar3], [], "hexpm", "d6137d7079169d8c485c6962dfe261af5b9ef60fbc557344511c1e65e3d95fb0"},
+  "hpax": {:hex, :hpax, "1.0.4", "777de5d433b0fbdc7c418159c8055910faa8047ffdb3d6b31098d2a46cd7685c", [:mix], [], "hexpm", "afc7cb142ebcc2d01ce7816190b98ce5dd49e799111b24249f3443d730f377ca"},
+  "httpoison": {:hex, :httpoison, "1.8.2", "9eb9c63ae289296a544842ef816a85d881d4a31f518a0fec089aaa744beae290", [:mix], [{:hackney, "~> 1.17", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "2bb350d26972e30c96e2ca74a1aaf8293d61d0742ff17f01e0279fef11599921"},
+  "idna": {:hex, :idna, "6.1.1", "8a63070e9f7d0c62eb9d9fcb360a7de382448200fbbd1b106cc96d3d8099df8d", [:rebar3], [{:unicode_util_compat, "~>0.7.0", [hex: :unicode_util_compat, repo: "hexpm", optional: false]}], "hexpm", "92376eb7894412ed19ac475e4a86f7b413c1b9fbb5bd16dccd57934157944cea"},
+  "jason": {:hex, :jason, "1.4.5", "2e3a008590b0b8d7388c20293e9dcc9cf3e5d642fd2a114e4cbbb52e595d940a", [:mix], [{:decimal, "~> 1.0 or ~> 2.0 or ~> 3.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm", "b0c823996102bcd0239b3c2444eb00409b72f6a140c1950bc8b457d836b30684"},
+  "joken": {:hex, :joken, "2.6.2", "5daaf82259ca603af4f0b065475099ada1b2b849ff140ccd37f4b6828ca6892a", [:mix], [{:jose, "~> 1.11.10", [hex: :jose, repo: "hexpm", optional: false]}], "hexpm", "5134b5b0a6e37494e46dbf9e4dad53808e5e787904b7c73972651b51cce3d72b"},
+  "jose": {:hex, :jose, "1.11.12", "06e62b467b61d3726cbc19e9b5489f7549c37993de846dfb3ee8259f9ed208b3", [:mix, :rebar3], [], "hexpm", "31e92b653e9210b696765cdd885437457de1add2a9011d92f8cf63e4641bab7b"},
+  "lazy_html": {:hex, :lazy_html, "0.1.10", "ffe42a0b4e70859cf21a33e12a251e0c76c1dff76391609bd56702a0ef5bc429", [:make, :mix], [{:cc_precompiler, "~> 0.1", [hex: :cc_precompiler, repo: "hexpm", optional: false]}, {:elixir_make, "~> 0.9.0", [hex: :elixir_make, repo: "hexpm", optional: false]}, {:fine, "~> 0.1.0", [hex: :fine, repo: "hexpm", optional: false]}], "hexpm", "50f67e5faa09d45a99c1ddf3fac004f051997877dc8974c5797bb5ccd8e27058"},
+  "libcluster": {:hex, :libcluster, "3.5.0", "5ee4cfde4bdf32b2fef271e33ce3241e89509f4344f6c6a8d4069937484866ba", [:mix], [{:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.3", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "ebf6561fcedd765a4cd43b4b8c04b1c87f4177b5fb3cbdfe40a780499d72f743"},
+  "location": {:git, "https://github.com/plausible/location.git", "a89bf79985c3c3d0830477ae587001156a646ce8", []},
+  "locus": {:hex, :locus, "2.3.12", "aa3992023363a523e5c6d0d104da1cd1026626d16b32a480903083201057f281", [:rebar3], [{:tls_certificate_check, "~> 1.9", [hex: :tls_certificate_check, repo: "hexpm", optional: false]}], "hexpm", "e9bacd644127c5aaac478461e8b4bcd49479e7bb9f665b48ab4ebac2b7adc1ec"},
+  "logger_backends": {:hex, :logger_backends, "1.0.1", "08a9bd09eed271eac41ff35dd7603b6abf9e0f8b6ffe40359846cb0bfd37704f", [:mix], [], "hexpm", "d7903244fe8d84eeb3d3d42f8d7de080fd0409b613040df54c78b3591672d652"},
+  "mail": {:hex, :mail, "0.4.4", "2ed92e3b2dedb2013ba8eef9fb7ace3892e0eae1f45c0658738a72c195f7649b", [:mix], [], "hexpm", "bd44bf3e253d8be9c7f2e59b3253aff1efc1c9fa7d8ab4430c96780683faa8e2"},
+  "makeup": {:hex, :makeup, "1.2.1", "e90ac1c65589ef354378def3ba19d401e739ee7ee06fb47f94c687016e3713d1", [:mix], [{:nimble_parsec, "~> 1.4", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "d36484867b0bae0fea568d10131197a4c2e47056a6fbe84922bf6ba71c8d17ce"},
+  "makeup_elixir": {:hex, :makeup_elixir, "1.0.1", "e928a4f984e795e41e3abd27bfc09f51db16ab8ba1aebdba2b3a575437efafc2", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 1.2.3 or ~> 1.3", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm", "7284900d412a3e5cfd97fdaed4f5ed389b8f2b4cb49efc0eb3bd10e2febf9507"},
+  "makeup_erlang": {:hex, :makeup_erlang, "1.0.1", "c7f58c120b2b5aa5fd80d540a89fdf866ed42f1f3994e4fe189abebeab610839", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm", "8a89a1eeccc2d798d6ea15496a6e4870b75e014d1af514b1b71fa33134f57814"},
+  "metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], [], "hexpm", "69b09adddc4f74a40716ae54d140f93beb0fb8978d8636eaded0c31b6f099f16"},
+  "mime": {:hex, :mime, "2.0.7", "b8d739037be7cd402aee1ba0306edfdef982687ee7e9859bee6198c1e7e2f128", [:mix], [], "hexpm", "6171188e399ee16023ffc5b76ce445eb6d9672e2e241d2df6050f3c771e80ccd"},
+  "mimerl": {:hex, :mimerl, "1.4.0", "3882a5ca67fbbe7117ba8947f27643557adec38fa2307490c4c4207624cb213b", [:rebar3], [], "hexpm", "13af15f9f68c65884ecca3a3891d50a7b57d82152792f3e19d88650aa126b144"},
+  "mint": {:hex, :mint, "1.9.1", "3bc120b743ed2e99ad920910f2613e9faebabb2257731b0e2ea4d8ccd9eceede", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}, {:hpax, "~> 0.1.1 or ~> 0.2.0 or ~> 1.0", [hex: :hpax, repo: "hexpm", optional: false]}], "hexpm", "831101bd560b086316fab5f7adb21a4f3455717d8e4bc8368b052e09aa9163e0"},
+  "mjml": {:hex, :mjml, "4.0.0", "3418c1a975112766f92b8786a17d53640a4a1c8c7dedb621016a08e1e1447d20", [:mix], [{:rustler, ">= 0.0.0", [hex: :rustler, repo: "hexpm", optional: true]}, {:rustler_precompiled, "~> 0.7.0", [hex: :rustler_precompiled, repo: "hexpm", optional: false]}], "hexpm", "0886a411f9a850bc4ac6b878c9c0dbea168669176fde1f6583acf55fa8b628dd"},
+  "mjml_eex": {:hex, :mjml_eex, "0.12.0", "ee7e58a0b2f361812c024ddd2dd57ccd4107e486632016fcf707d4d0eaa04d62", [:mix], [{:erlexec, "~> 2.0.7", [hex: :erlexec, repo: "hexpm", optional: true]}, {:mjml, "~> 4.0", [hex: :mjml, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.2 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "6ca41f6252669b709d31d8b7c74db00c8bc3784dea1913b406a68c12763c5bcb"},
+  "mox": {:hex, :mox, "1.2.0", "a2cd96b4b80a3883e3100a221e8adc1b98e4c3a332a8fc434c39526babafd5b3", [:mix], [{:nimble_ownership, "~> 1.0", [hex: :nimble_ownership, repo: "hexpm", optional: false]}], "hexpm", "c7b92b3cc69ee24a7eeeaf944cd7be22013c52fcb580c1f33f50845ec821089a"},
+  "mua": {:hex, :mua, "0.2.5", "e99aa9646964a0109a2efcc8e684c6f8d90c60fb0191f52e1784cea296584daf", [:mix], [{:castore, "~> 0.1.0 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: true]}], "hexpm", "0e2b18024d0db8943a68e84fb5e2253d3225c8f61d8387cbfc581d66e34d8493"},
+  "nanoid": {:hex, :nanoid, "2.1.0", "d192a5bf1d774258bc49762b480fca0e3128178fa6d35a464af2a738526607fd", [:mix], [], "hexpm", "ebc7a342d02d213534a7f93a091d569b9fea7f26fcd3a638dc655060fc1f76ac"},
+  "nimble_csv": {:hex, :nimble_csv, "1.3.0", "b7f998dc62b222bce9596e46f028c7a5af04cb5dde6df2ea197c583227c54971", [:mix], [], "hexpm", "41ccdc18f7c8f8bb06e84164fc51635321e80d5a3b450761c4997d620925d619"},
+  "nimble_options": {:hex, :nimble_options, "1.1.1", "e3a492d54d85fc3fd7c5baf411d9d2852922f66e69476317787a7b2bb000a61b", [:mix], [], "hexpm", "821b2470ca9442c4b6984882fe9bb0389371b8ddec4d45a9504f00a66f650b44"},
+  "nimble_ownership": {:hex, :nimble_ownership, "1.0.2", "fa8a6f2d8c592ad4d79b2ca617473c6aefd5869abfa02563a77682038bf916cf", [:mix], [], "hexpm", "098af64e1f6f8609c6672127cfe9e9590a5d3fcdd82bc17a377b8692fd81a879"},
+  "nimble_parsec": {:hex, :nimble_parsec, "1.4.2", "8efba0122db06df95bfaa78f791344a89352ba04baedd3849593bfce4d0dc1c6", [:mix], [], "hexpm", "4b21398942dda052b403bbe1da991ccd03a053668d147d53fb8c4e0efe09c973"},
+  "nimble_pool": {:hex, :nimble_pool, "1.1.0", "bf9c29fbdcba3564a8b800d1eeb5a3c58f36e1e11d7b7fb2e084a643f645f06b", [:mix], [], "hexpm", "af2e4e6b34197db81f7aad230c1118eac993acc0dae6bc83bac0126d4ae0813a"},
+  "nimble_totp": {:hex, :nimble_totp, "1.0.0", "79753bae6ce59fd7cacdb21501a1dbac249e53a51c4cd22b34fa8438ee067283", [:mix], [], "hexpm", "6ce5e4c068feecdb782e85b18237f86f66541523e6bad123e02ee1adbe48eda9"},
+  "oban": {:hex, :oban, "2.20.1", "39d0b68787e5cf251541c0d657a698f6142a24d8744e1e40b2cf045d4fa232a6", [:mix], [{:ecto_sql, "~> 3.10", [hex: :ecto_sql, repo: "hexpm", optional: false]}, {:ecto_sqlite3, "~> 0.9", [hex: :ecto_sqlite3, repo: "hexpm", optional: true]}, {:igniter, "~> 0.5", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: true]}, {:myxql, "~> 0.7", [hex: :myxql, repo: "hexpm", optional: true]}, {:postgrex, "~> 0.20", [hex: :postgrex, repo: "hexpm", optional: true]}, {:telemetry, "~> 1.3", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "17a45277dbeb41a455040b41dd8c467163fad685d1366f2f59207def3bcdd1d8"},
+  "observer_cli": {:hex, :observer_cli, "1.7.4", "3c1bfb6d91bf68f6a3d15f46ae20da0f7740d363ee5bc041191ce8722a6c4fae", [:mix, :rebar3], [{:recon, "~> 2.5.1", [hex: :recon, repo: "hexpm", optional: false]}], "hexpm", "50de6d95d814f447458bd5d72666a74624eddb0ef98bdcee61a0153aae0865ff"},
+  "octo_fetch": {:hex, :octo_fetch, "0.4.0", "074b5ecbc08be10b05b27e9db08bc20a3060142769436242702931c418695b19", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:ssl_verify_fun, "~> 1.1", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "hexpm", "cf8be6f40cd519d7000bb4e84adcf661c32e59369ca2827c4e20042eda7a7fc6"},
+  "odgn_json_pointer": {:hex, :odgn_json_pointer, "3.1.0", "be81198ad8c9bce01fc872d6400d88a4a55ce711f7c8838e1166bd21f736d29a", [:mix], [], "hexpm", "85730306bb2e5796c993813f35e9bafeb561526f5e80a517793c33d1635ade94"},
+  "open_api_spex": {:hex, :open_api_spex, "3.22.1", "38c99d8bf107dc7ffb112dc669f33e0a287396c6c9fd6bb7eeb27e3fe8dbba0e", [:mix], [{:decimal, "~> 1.0 or ~> 2.0", [hex: :decimal, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:plug, "~> 1.7", [hex: :plug, repo: "hexpm", optional: false]}, {:poison, "~> 3.0 or ~> 4.0 or ~> 5.0 or ~> 6.0", [hex: :poison, repo: "hexpm", optional: true]}, {:ymlr, "~> 2.0 or ~> 3.0 or ~> 4.0 or ~> 5.0", [hex: :ymlr, repo: "hexpm", optional: true]}], "hexpm", "fa51ecd04ececbad89a8ede55ebd9db7aa9e55cc7ddbb46455522e0f3c098290"},
+  "opentelemetry": {:hex, :opentelemetry, "1.7.0", "20d0f12d3d1c398d3670fd44fd1a7c495dd748ab3e5b692a7906662e2fb1a38a", [:rebar3], [{:opentelemetry_api, "~> 1.5.0", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}], "hexpm", "a9173b058c4549bf824cbc2f1d2fa2adc5cdedc22aa3f0f826951187bbd53131"},
+  "opentelemetry_api": {:hex, :opentelemetry_api, "1.5.0", "1a676f3e3340cab81c763e939a42e11a70c22863f645aa06aafefc689b5550cf", [:mix, :rebar3], [], "hexpm", "f53ec8a1337ae4a487d43ac89da4bd3a3c99ddf576655d071deed8b56a2d5dda"},
+  "opentelemetry_api_experimental": {:git, "https://github.com/open-telemetry/opentelemetry-erlang.git", "b241ebf4feb7558738d009583bae8602b3c49fd0", [ref: "b241ebf4feb7558738d009583bae8602b3c49fd0", sparse: "apps/opentelemetry_api_experimental"]},
+  "opentelemetry_cowboy": {:hex, :opentelemetry_cowboy, "1.0.0", "786c7cde66a2493323c79d2c94e679ff501d459a9b403d8b60b9bef116333117", [:rebar3], [{:cowboy_telemetry, "~> 0.4", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:opentelemetry_api, "~> 1.4", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}, {:opentelemetry_semantic_conventions, "~> 1.27", [hex: :opentelemetry_semantic_conventions, repo: "hexpm", optional: false]}, {:opentelemetry_telemetry, "~> 1.1", [hex: :opentelemetry_telemetry, repo: "hexpm", optional: false]}, {:otel_http, "~> 0.2", [hex: :otel_http, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.1", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "7575716eaccacd0eddc3e7e61403aecb5d0a6397183987d6049094aeb0b87a7c"},
+  "opentelemetry_ecto": {:hex, :opentelemetry_ecto, "1.2.0", "2382cb47ddc231f953d3b8263ed029d87fbf217915a1da82f49159d122b64865", [:mix], [{:opentelemetry_api, "~> 1.0", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}, {:opentelemetry_process_propagator, "~> 0.2", [hex: :opentelemetry_process_propagator, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "70dfa2e79932e86f209df00e36c980b17a32f82d175f0068bf7ef9a96cf080cf"},
+  "opentelemetry_experimental": {:git, "https://github.com/open-telemetry/opentelemetry-erlang.git", "b241ebf4feb7558738d009583bae8602b3c49fd0", [ref: "b241ebf4feb7558738d009583bae8602b3c49fd0", sparse: "apps/opentelemetry_experimental"]},
+  "opentelemetry_exporter": {:hex, :opentelemetry_exporter, "1.10.0", "972e142392dbfa679ec959914664adefea38399e4f56ceba5c473e1cabdbad79", [:rebar3], [{:grpcbox, ">= 0.0.0", [hex: :grpcbox, repo: "hexpm", optional: false]}, {:opentelemetry, "~> 1.7.0", [hex: :opentelemetry, repo: "hexpm", optional: false]}, {:opentelemetry_api, "~> 1.5.0", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}, {:tls_certificate_check, "~> 1.18", [hex: :tls_certificate_check, repo: "hexpm", optional: false]}], "hexpm", "33a116ed7304cb91783f779dec02478f887c87988077bfd72840f760b8d4b952"},
+  "opentelemetry_oban": {:hex, :opentelemetry_oban, "1.1.1", "519e9ba60d3dc3483ad2df3fade131d47056e0dae74f0724c8a40b9718f089d1", [:mix], [{:oban, "~> 2.0", [hex: :oban, repo: "hexpm", optional: false]}, {:opentelemetry_api, "~> 1.2", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}, {:opentelemetry_semantic_conventions, "~> 0.2", [hex: :opentelemetry_semantic_conventions, repo: "hexpm", optional: false]}, {:opentelemetry_telemetry, "~> 1.1", [hex: :opentelemetry_telemetry, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "ae6aed431626a94a4bb6bf5b268247ced687ec8f99eced6887e3754f9d3a2089"},
+  "opentelemetry_phoenix": {:hex, :opentelemetry_phoenix, "2.0.1", "c664cdef205738cffcd409b33599439a4ffb2035ef6e21a77927ac1da90463cb", [:mix], [{:nimble_options, "~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:opentelemetry_api, "~> 1.4", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}, {:opentelemetry_process_propagator, "~> 0.3", [hex: :opentelemetry_process_propagator, repo: "hexpm", optional: false]}, {:opentelemetry_semantic_conventions, "~> 1.27", [hex: :opentelemetry_semantic_conventions, repo: "hexpm", optional: false]}, {:opentelemetry_telemetry, "~> 1.1", [hex: :opentelemetry_telemetry, repo: "hexpm", optional: false]}, {:otel_http, "~> 0.2", [hex: :otel_http, repo: "hexpm", optional: false]}, {:plug, ">= 1.11.0", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "a24fdccdfa6b890c8892c6366beab4a15a27ec0c692b0f77ec2a862e7b235f6e"},
+  "opentelemetry_process_propagator": {:hex, :opentelemetry_process_propagator, "0.3.0", "ef5b2059403a1e2b2d2c65914e6962e56371570b8c3ab5323d7a8d3444fb7f84", [:mix, :rebar3], [{:opentelemetry_api, "~> 1.0", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}], "hexpm", "7243cb6de1523c473cba5b1aefa3f85e1ff8cc75d08f367104c1e11919c8c029"},
+  "opentelemetry_req": {:hex, :opentelemetry_req, "1.0.0", "f8ef479a05311bdc030925a07be869ede45e8158cc2c80d9855e35a7d1efc89c", [:mix], [{:jason, "~> 1.3", [hex: :jason, repo: "hexpm", optional: false]}, {:nimble_options, "~> 1.1", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:opentelemetry_api, "~> 1.4", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}, {:opentelemetry_semantic_conventions, "~> 1.27", [hex: :opentelemetry_semantic_conventions, repo: "hexpm", optional: false]}, {:otel_http, "~> 0.2", [hex: :otel_http, repo: "hexpm", optional: false]}, {:req, ">= 0.3.5", [hex: :req, repo: "hexpm", optional: false]}], "hexpm", "6404ae802d694f7c3e5b43bf41af99364ecf20c3f5fea144fff8b7f873b22bf7"},
+  "opentelemetry_semantic_conventions": {:hex, :opentelemetry_semantic_conventions, "1.27.0", "acd0194a94a1e57d63da982ee9f4a9f88834ae0b31b0bd850815fe9be4bbb45f", [:mix, :rebar3], [], "hexpm", "9681ccaa24fd3d810b4461581717661fd85ff7019b082c2dff89c7d5b1fc2864"},
+  "opentelemetry_telemetry": {:hex, :opentelemetry_telemetry, "1.1.2", "410ab4d76b0921f42dbccbe5a7c831b8125282850be649ee1f70050d3961118a", [:mix, :rebar3], [{:opentelemetry_api, "~> 1.3", [hex: :opentelemetry_api, repo: "hexpm", optional: false]}, {:telemetry, "~> 1.1", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "641ab469deb181957ac6d59bce6e1321d5fe2a56df444fc9c19afcad623ab253"},
+  "otel_http": {:hex, :otel_http, "0.2.0", "b17385986c7f1b862f5d577f72614ecaa29de40392b7618869999326b9a61d8a", [:rebar3], [], "hexpm", "f2beadf922c8cfeb0965488dd736c95cc6ea8b9efce89466b3904d317d7cc717"},
+  "paginator": {:git, "https://github.com/duffelhq/paginator.git", "3508d6ad77a95ac1faf15d5fd7f959fab3e17da2", []},
+  "parent": {:hex, :parent, "0.12.1", "495c4386f06de0df492e0a7a7199c10323a55e9e933b27222060dd86dccd6d62", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "2ab589ef1f37bfcedbfb5ecfbab93354972fb7391201b8907a866dadd20b39d1"},
+  "parse_trans": {:hex, :parse_trans, "3.4.1", "6e6aa8167cb44cc8f39441d05193be6e6f4e7c2946cb2759f015f8c56b76e5ff", [:rebar3], [], "hexpm", "620a406ce75dada827b82e453c19cf06776be266f5a67cff34e1ef2cbb60e49a"},
+  "peep": {:hex, :peep, "3.4.2", "49d4ca116d994779351959dfee971fb2c7d6506f1821374f3cc4fd39a3d3fadb", [:mix], [{:nimble_options, "~> 1.1", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:plug, "~> 1.16", [hex: :plug, repo: "hexpm", optional: true]}, {:telemetry_metrics, "~> 1.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "cae224b09e224bf5584f5375108becf71e2288572a099a122e66735289cd33f4"},
+  "phoenix": {:hex, :phoenix, "1.8.9", "a63ed0962ed5b903b146dab0ae8eb8387fe478f8171a5e26d56a165f35996fe1", [:mix], [{:bandit, "~> 1.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 2.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.7", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:plug_crypto, "~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:websock_adapter, "~> 0.5", [hex: :websock_adapter, repo: "hexpm", optional: false]}], "hexpm", "3477e2dd5a4f61820341169031bdfe21275f659923bea9c5c0ea2aa1c3fcc046"},
+  "phoenix_bakery": {:hex, :phoenix_bakery, "0.1.2", "ca57673caea1a98f1cc763f94032796a015774d27eaa3ce5feef172195470452", [:mix], [{:brotli, "~> 0.3.0", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "45cc8cecc5c3002b922447c16389761718c07c360432328b04680034e893ea5b"},
+  "phoenix_ecto": {:hex, :phoenix_ecto, "4.7.0", "75c4b9dfb3efdc42aec2bd5f8bccd978aca0651dbcbc7a3f362ea5d9d43153c6", [:mix], [{:ecto, "~> 3.5", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.1", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}, {:postgrex, "~> 0.16 or ~> 1.0", [hex: :postgrex, repo: "hexpm", optional: true]}], "hexpm", "1d75011e4254cb4ddf823e81823a9629559a1be93b4321a6a5f11a5306fbf4cc"},
+  "phoenix_html": {:hex, :phoenix_html, "4.3.0", "d3577a5df4b6954cd7890c84d955c470b5310bb49647f0a114a6eeecc850f7ad", [:mix], [], "hexpm", "3eaa290a78bab0f075f791a46a981bbe769d94bc776869f4f3063a14f30497ad"},
+  "phoenix_html_helpers": {:hex, :phoenix_html_helpers, "1.0.1", "7eed85c52eff80a179391036931791ee5d2f713d76a81d0d2c6ebafe1e11e5ec", [:mix], [{:phoenix_html, "~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "cffd2385d1fa4f78b04432df69ab8da63dc5cf63e07b713a4dcf36a3740e3090"},
+  "phoenix_live_reload": {:hex, :phoenix_live_reload, "1.6.1", "05df733a09887a005ed0d69a7fc619d376aea2730bf64ce52ac51ce716cc1ef0", [:mix], [{:file_system, "~> 0.2.10 or ~> 1.0", [hex: :file_system, repo: "hexpm", optional: false]}, {:phoenix, "~> 1.4", [hex: :phoenix, repo: "hexpm", optional: false]}], "hexpm", "74273843d5a6e4fef0bbc17599f33e3ec63f08e69215623a0cd91eea4288e5a0"},
+  "phoenix_live_view": {:hex, :phoenix_live_view, "1.1.27", "9afcab28b0c82afdc51044e661bcd5b8de53d242593d34c964a37710b40a42af", [:mix], [{:igniter, ">= 0.6.16 and < 1.0.0-0", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:lazy_html, "~> 0.1.0", [hex: :lazy_html, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6.15 or ~> 1.7.0 or ~> 1.8.0-rc", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 3.3 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}, {:phoenix_view, "~> 2.0", [hex: :phoenix_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.15", [hex: :plug, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.2 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "415735d0b2c612c9104108b35654e977626a0cb346711e1e4f1ed16e3c827ede"},
+  "phoenix_pubsub": {:hex, :phoenix_pubsub, "2.2.0", "ff3a5616e1bed6804de7773b92cbccfc0b0f473faf1f63d7daf1206c7aeaaa6f", [:mix], [], "hexpm", "adc313a5bf7136039f63cfd9668fde73bba0765e0614cba80c06ac9460ff3e96"},
+  "phoenix_template": {:hex, :phoenix_template, "1.0.4", "e2092c132f3b5e5b2d49c96695342eb36d0ed514c5b252a77048d5969330d639", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}], "hexpm", "2c0c81f0e5c6753faf5cca2f229c9709919aba34fab866d3bc05060c9c444206"},
+  "phoenix_view": {:hex, :phoenix_view, "2.0.4", "b45c9d9cf15b3a1af5fb555c674b525391b6a1fe975f040fb4d913397b31abf4", [:mix], [{:phoenix_html, "~> 2.14.2 or ~> 3.0 or ~> 4.0", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_template, "~> 1.0", [hex: :phoenix_template, repo: "hexpm", optional: false]}], "hexpm", "4e992022ce14f31fe57335db27a28154afcc94e9983266835bb3040243eb620b"},
+  "php_serializer": {:hex, :php_serializer, "2.0.0", "b43f31aca22ed7321f32da2b94fe2ddf9b6739a965cb51541969119e572e821d", [:mix], [], "hexpm", "61e402e99d9062c0225a3f4fcf7e43b4cba1b8654944c0e7c139c3ca9de481da"},
+  "plug": {:hex, :plug, "1.20.2", "adbee2441232412e37fbb357fd5e4cd533fdd253b29f2e1992262b0f1fb01462", [:mix], [{:mime, "~> 1.0 or ~> 2.0", [hex: :mime, repo: "hexpm", optional: false]}, {:plug_crypto, "~> 1.1.1 or ~> 1.2 or ~> 2.0", [hex: :plug_crypto, repo: "hexpm", optional: false]}, {:telemetry, "~> 0.4.3 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "b16baf55877d60891002ffc1ce0b3ff7d6f30a38a23e02e4d4293c4ac266f136"},
+  "plug_cowboy": {:hex, :plug_cowboy, "2.8.1", "5aa391a5e8d1ac3192e36a3bcaff12b5fd6ef6c7e29b53a38e63a860783e77d0", [:mix], [{:cowboy, "~> 2.7", [hex: :cowboy, repo: "hexpm", optional: false]}, {:cowboy_telemetry, "~> 0.3", [hex: :cowboy_telemetry, repo: "hexpm", optional: false]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm", "4c200288673d5bc86a0ab7dc6a2a069176a74e5d573ef62740a1c517458a5f26"},
+  "plug_crypto": {:hex, :plug_crypto, "1.2.5", "918772575e48e81e455818229bf719d4ab4181fcbf7f85b68a35620f78d89ced", [:mix], [], "hexpm", "26549a1d6345e2172eb1c233866756ae44a9609bd33ee6f99147ab3fd87fd842"},
+  "polymorphic_embed": {:hex, :polymorphic_embed, "5.0.3", "37444e0af941026a2c29b0539b6471bdd6737a6492a19264bf2bb0118e3ac242", [:mix], [{:attrs, "~> 0.6", [hex: :attrs, repo: "hexpm", optional: false]}, {:ecto, "~> 3.12", [hex: :ecto, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 4.1", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:phoenix_html_helpers, "~> 1.0", [hex: :phoenix_html_helpers, repo: "hexpm", optional: true]}, {:phoenix_live_view, "~> 0.20 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}], "hexpm", "2fed44f57abf0a0fc7642e0eb0807a55b65de1562712cc0620772cbbb80e49c1"},
+  "postgrex": {:hex, :postgrex, "0.22.2", "4aec14df2a72722aee92492566edbeeb44e233ecb86b1915d03136297ef1385d", [:mix], [{:db_connection, "~> 2.9", [hex: :db_connection, repo: "hexpm", optional: false]}, {:decimal, "~> 1.5 or ~> 2.0 or ~> 3.0", [hex: :decimal, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:table, "~> 0.1.0", [hex: :table, repo: "hexpm", optional: true]}], "hexpm", "8946382ddb06294f56026ac4278b3cc212bac8a2c82ed68b4087819ed1abc53b"},
+  "prima": {:hex, :prima, "0.2.6", "a40993d108760a711c2da183cff20234497e977f6155aad1ee5e17a3b00a46b6", [:mix], [{:esbuild, "~> 0.7", [hex: :esbuild, repo: "hexpm", optional: false]}, {:phoenix, ">= 1.7.0", [hex: :phoenix, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 4.2", [hex: :phoenix_html, repo: "hexpm", optional: false]}, {:phoenix_live_view, "~> 1.1", [hex: :phoenix_live_view, repo: "hexpm", optional: false]}], "hexpm", "00ec378bd7b0c58d58043e59581f9aa5ba35a0d5031e011e36c449d3a0b7418c"},
+  "prom_ex": {:hex, :prom_ex, "1.11.0", "1f6d67f2dead92224cb4f59beb3e4d319257c5728d9638b4a5e8ceb51a4f9c7e", [:mix], [{:absinthe, ">= 1.7.0", [hex: :absinthe, repo: "hexpm", optional: true]}, {:broadway, ">= 1.1.0", [hex: :broadway, repo: "hexpm", optional: true]}, {:ecto, ">= 3.11.0", [hex: :ecto, repo: "hexpm", optional: true]}, {:finch, "~> 0.18", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.4", [hex: :jason, repo: "hexpm", optional: false]}, {:oban, ">= 2.10.0", [hex: :oban, repo: "hexpm", optional: true]}, {:octo_fetch, "~> 0.4", [hex: :octo_fetch, repo: "hexpm", optional: false]}, {:peep, "~> 3.0", [hex: :peep, repo: "hexpm", optional: false]}, {:phoenix, ">= 1.7.0", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_live_view, ">= 0.20.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}, {:plug, ">= 1.16.0", [hex: :plug, repo: "hexpm", optional: true]}, {:plug_cowboy, ">= 2.6.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, ">= 1.0.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 1.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}, {:telemetry_metrics_prometheus_core, "~> 1.2", [hex: :telemetry_metrics_prometheus_core, repo: "hexpm", optional: false]}, {:telemetry_poller, "~> 1.1", [hex: :telemetry_poller, repo: "hexpm", optional: false]}], "hexpm", "76b074bc3730f0802978a7eb5c7091a65473eaaf07e99ec9e933138dcc327805"},
+  "public_suffix": {:git, "https://github.com/axelson/publicsuffix-elixir", "fa40c243d4b5d8598b90cff268bc4e33f3bb63f1", []},
+  "ranch": {:hex, :ranch, "1.8.1", "208169e65292ac5d333d6cdbad49388c1ae198136e4697ae2f474697140f201c", [:make, :rebar3], [], "hexpm", "aed58910f4e21deea992a67bf51632b6d60114895eb03bb392bb733064594dd0"},
+  "recon": {:hex, :recon, "2.5.4", "05dd52a119ee4059fa9daa1ab7ce81bc7a8161a2f12e9d42e9d551ffd2ba901c", [:mix, :rebar3], [], "hexpm", "e9ab01ac7fc8572e41eb59385efeb3fb0ff5bf02103816535bacaedf327d0263"},
+  "ref_inspector": {:hex, :ref_inspector, "2.0.0", "f3e97e51d9782de4c792f56eed26c80903bc39174c878285392ce76d5e67fe98", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}, {:yamerl, "~> 0.7", [hex: :yamerl, repo: "hexpm", optional: false]}], "hexpm", "bf62f3f1a87d6b8b30f457a480668f965373e64f184611282b5e89d8dd81fd33"},
+  "referrer_blocklist": {:git, "https://github.com/plausible/referrer-blocklist.git", "d6f52c225cccb4f04b80e3a5d588868ec234139d", []},
+  "req": {:hex, :req, "0.6.2", "b9b2024f35bcf60a92cc8cad2eaaf9d4e7aace463ff74be1afe5986830184413", [:mix], [{:brotli, "~> 0.3.1", [hex: :brotli, repo: "hexpm", optional: true]}, {:ezstd, "~> 1.0", [hex: :ezstd, repo: "hexpm", optional: true]}, {:finch, "~> 0.21", [hex: :finch, repo: "hexpm", optional: false]}, {:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: false]}, {:mime, "~> 2.0.6 or ~> 2.1", [hex: :mime, repo: "hexpm", optional: false]}, {:nimble_csv, "~> 1.0", [hex: :nimble_csv, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: true]}], "hexpm", "cc9cd30a2ddd04989929b887178e1610c940456d962c6c3a52df6146d2eef9bf"},
+  "rustler_precompiled": {:hex, :rustler_precompiled, "0.7.3", "42cb9449785cd86c87453e39afdd27a0bdfa5c77a4ec5dc5ce45112e06b9f89b", [:mix], [{:castore, "~> 0.1 or ~> 1.0", [hex: :castore, repo: "hexpm", optional: false]}, {:rustler, "~> 0.23", [hex: :rustler, repo: "hexpm", optional: true]}], "hexpm", "cbc4b3777682e5f6f43ed39b0e0b4a42dccde8053aba91b4514e8f5ff9a5ac6d"},
+  "saxy": {:hex, :saxy, "1.6.0", "02cb4e9bd045f25ac0c70fae8164754878327ee393c338a090288210b02317ee", [:mix], [], "hexpm", "ef42eb4ac983ca77d650fbdb68368b26570f6cc5895f0faa04d34a6f384abad3"},
+  "sentry": {:hex, :sentry, "11.0.4", "60371c96cefd247e0fc98840bba2648f64f19aa0b8db8e938f5a98421f55b619", [:mix], [{:hackney, "~> 1.8", [hex: :hackney, repo: "hexpm", optional: true]}, {:igniter, "~> 0.5", [hex: :igniter, repo: "hexpm", optional: true]}, {:jason, "~> 1.1", [hex: :jason, repo: "hexpm", optional: true]}, {:nimble_options, "~> 1.0", [hex: :nimble_options, repo: "hexpm", optional: false]}, {:nimble_ownership, "~> 0.3.0 or ~> 1.0", [hex: :nimble_ownership, repo: "hexpm", optional: false]}, {:opentelemetry, ">= 0.0.0", [hex: :opentelemetry, repo: "hexpm", optional: true]}, {:opentelemetry_api, ">= 0.0.0", [hex: :opentelemetry_api, repo: "hexpm", optional: true]}, {:opentelemetry_exporter, ">= 0.0.0", [hex: :opentelemetry_exporter, repo: "hexpm", optional: true]}, {:opentelemetry_semantic_conventions, ">= 0.0.0", [hex: :opentelemetry_semantic_conventions, repo: "hexpm", optional: true]}, {:phoenix, "~> 1.6", [hex: :phoenix, repo: "hexpm", optional: true]}, {:phoenix_live_view, "~> 0.20 or ~> 1.0", [hex: :phoenix_live_view, repo: "hexpm", optional: true]}, {:plug, "~> 1.6", [hex: :plug, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: true]}], "hexpm", "feaafc284dc204c82aadaddc884227aeaa3480decb274d30e184b9d41a700c66"},
+  "simple_saml": {:hex, :simple_saml, "1.2.0", "d875939e21cd73cdb3f747e701e4d2d5f0f4e35610d37df50629087454fa43f9", [:mix], [{:simple_xml, "~> 1.3", [hex: :simple_xml, repo: "hexpm", optional: false]}, {:x509, "~> 0.9.0", [hex: :x509, repo: "hexpm", optional: false]}], "hexpm", "24663665e53a91bfc38359ed9f26f575a389bde9fc94ec369f9f2259046feaf0"},
+  "simple_xml": {:hex, :simple_xml, "1.3.2", "84b892527b5183748694583a658c729c84bb89fc8ac650d7025ebc2c49e74018", [:mix], [{:saxy, "~> 1.5", [hex: :saxy, repo: "hexpm", optional: false]}, {:x509, "~> 0.9.0", [hex: :x509, repo: "hexpm", optional: false]}], "hexpm", "8c15fa49955a8c82b50f3053617e8a4cd771fcd0a502d660e56993c38ac86ca5"},
+  "siphash": {:hex, :siphash, "3.2.0", "ec03fd4066259218c85e2a4b8eec4bb9663bc02b127ea8a0836db376ba73f2ed", [:make, :mix], [], "hexpm", "ba3810701c6e95637a745e186e8a4899087c3b079ba88fb8f33df054c3b0b7c3"},
+  "site_encrypt": {:git, "https://github.com/sasa1977/site_encrypt.git", "8d47801c51eeea11ac385cb73eef4ed9a6565367", []},
+  "ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.7", "354c321cf377240c7b8716899e182ce4890c5938111a1296add3ec74cf1715df", [:make, :mix, :rebar3], [], "hexpm", "fe4c190e8f37401d30167c8c405eda19469f34577987c76dde613e838bbc67f8"},
+  "sweet_xml": {:hex, :sweet_xml, "0.7.5", "803a563113981aaac202a1dbd39771562d0ad31004ddbfc9b5090bdcd5605277", [:mix], [], "hexpm", "193b28a9b12891cae351d81a0cead165ffe67df1b73fe5866d10629f4faefb12"},
+  "tailwind": {:hex, :tailwind, "0.4.1", "e7bcc222fe96a1e55f948e76d13dd84a1a7653fb051d2a167135db3b4b08d3e9", [:mix], [], "hexpm", "6249d4f9819052911120dbdbe9e532e6bd64ea23476056adb7f730aa25c220d1"},
+  "telemetry": {:hex, :telemetry, "1.4.2", "a0cb522801dffb1c49fe6e30561badffc7b6d0e180db1300df759faa22062855", [:rebar3], [], "hexpm", "928f6495066506077862c0d1646609eed891a4326bee3126ba54b60af61febb1"},
+  "telemetry_metrics": {:hex, :telemetry_metrics, "1.1.0", "5bd5f3b5637e0abea0426b947e3ce5dd304f8b3bc6617039e2b5a008adc02f8f", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "e7b79e8ddfde70adb6db8a6623d1778ec66401f366e9a8f5dd0955c56bc8ce67"},
+  "telemetry_metrics_prometheus_core": {:hex, :telemetry_metrics_prometheus_core, "1.2.1", "c9755987d7b959b557084e6990990cb96a50d6482c683fb9622a63837f3cd3d8", [:mix], [{:telemetry, "~> 0.4 or ~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}, {:telemetry_metrics, "~> 0.6 or ~> 1.0", [hex: :telemetry_metrics, repo: "hexpm", optional: false]}], "hexpm", "5e2c599da4983c4f88a33e9571f1458bf98b0cf6ba930f1dc3a6e8cf45d5afb6"},
+  "telemetry_poller": {:hex, :telemetry_poller, "1.3.0", "d5c46420126b5ac2d72bc6580fb4f537d35e851cc0f8dbd571acf6d6e10f5ec7", [:rebar3], [{:telemetry, "~> 1.0", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm", "51f18bed7128544a50f75897db9974436ea9bfba560420b646af27a9a9b35211"},
+  "timex": {:hex, :timex, "3.7.13", "0688ce11950f5b65e154e42b47bf67b15d3bc0e0c3def62199991b8a8079a1e2", [:mix], [{:combine, "~> 0.10", [hex: :combine, repo: "hexpm", optional: false]}, {:gettext, "~> 0.26", [hex: :gettext, repo: "hexpm", optional: false]}, {:tzdata, "~> 1.1", [hex: :tzdata, repo: "hexpm", optional: false]}], "hexpm", "09588e0522669328e973b8b4fd8741246321b3f0d32735b589f78b136e6d4c54"},
+  "tls_certificate_check": {:hex, :tls_certificate_check, "1.30.0", "ef9bdfcb5b551b747cad231a65ebd449623628bb72471c1d2aefcbbc5730683d", [:rebar3], [{:ssl_verify_fun, "~> 1.1", [hex: :ssl_verify_fun, repo: "hexpm", optional: false]}], "hexpm", "dfbada8fddb80ae19b8aeaac34d95cfce98c91393b0db9c3ee079b488fd68d81"},
+  "tzdata": {:hex, :tzdata, "1.1.3", "b1cef7bb6de1de90d4ddc25d33892b32830f907e7fc2fccd1e7e22778ab7dfbc", [:mix], [{:hackney, "~> 1.17", [hex: :hackney, repo: "hexpm", optional: false]}], "hexpm", "d4ca85575a064d29d4e94253ee95912edfb165938743dbf002acdf0dcecb0c28"},
+  "ua_inspector": {:hex, :ua_inspector, "3.12.0", "c8c5cfb0ce19b5cd609efb577bf75e3ed60deef8ed26bc0577aa2ff60ea49bcd", [:mix], [{:hackney, "~> 1.0", [hex: :hackney, repo: "hexpm", optional: false]}, {:yamerl, "~> 0.7", [hex: :yamerl, repo: "hexpm", optional: false]}], "hexpm", "81fa0e28effb50ae9fd74ffe51622af3846149aee32c11d60b16ceab62b45682"},
+  "unicode_util_compat": {:hex, :unicode_util_compat, "0.7.1", "a48703a25c170eedadca83b11e88985af08d35f37c6f664d6dcfb106a97782fc", [:rebar3], [], "hexpm", "b3a917854ce3ae233619744ad1e0102e05673136776fb2fa76234f3e03b23642"},
+  "websock": {:hex, :websock, "0.5.3", "2f69a6ebe810328555b6fe5c831a851f485e303a7c8ce6c5f675abeb20ebdadc", [:mix], [], "hexpm", "6105453d7fac22c712ad66fab1d45abdf049868f253cf719b625151460b8b453"},
+  "websock_adapter": {:hex, :websock_adapter, "0.5.9", "43dc3ba6d89ef5dec5b1d0a39698436a1e856d000d84bf31a3149862b01a287f", [:mix], [{:bandit, ">= 0.6.0", [hex: :bandit, repo: "hexpm", optional: true]}, {:plug, "~> 1.14", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 2.6", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:websock, "~> 0.5", [hex: :websock, repo: "hexpm", optional: false]}], "hexpm", "5534d5c9adad3c18a0f58a9371220d75a803bf0b9a3d87e6fe072faaeed76a08"},
+  "x509": {:hex, :x509, "0.9.2", "a75aa605348abd905990f3d2dc1b155fcde4e030fa2f90c4a91534405dce0f6e", [:mix], [], "hexpm", "4c5ede75697e565d4b0f5be04c3b71bb1fd3a090ea243af4bd7dae144e48cfc7"},
+  "xml_builder": {:hex, :xml_builder, "2.4.0", "b20d23077266c81f593360dc037ea398461dddb6638a329743da6c73afa56725", [:mix], [], "hexpm", "833e325bb997f032b5a1b740d2fd6feed3c18ca74627f9f5f30513a9ae1a232d"},
+  "yamerl": {:hex, :yamerl, "0.10.0", "4ff81fee2f1f6a46f1700c0d880b24d193ddb74bd14ef42cb0bcf46e81ef2f8e", [:rebar3], [], "hexpm", "346adb2963f1051dc837a2364e4acf6eb7d80097c0f53cbdc3046ec8ec4b4e6e"},
+  "zstream": {:hex, :zstream, "0.6.7", "ae74c7544f4e0563ffbe71324bf1c9bbc0ab33bb580a0ae718da511fb8a5c9d6", [:mix], [], "hexpm", "48c43ae0f00cfcda1ccb69c1d044755663d43b2ee8a0a65763648bf2078d634d"},
+  "zxcvbn": {:git, "https://github.com/techgaun/zxcvbn-elixir.git", "5c9684590f4ecf00af2d391f90db9ce93bd4e996", []},
+}

priv/custom_sources.json

@@ -0,0 +1,84 @@
+{
+  "bsky.app":"Bluesky",
+  "go.bsky.app":"Bluesky",
+  "android-app://com.reddit.frontpage":"Reddit",
+  "baidu.com":"Baidu",
+  "chatgpt.com":"ChatGPT",
+  "chat.openai.com":"ChatGPT",
+  "claude.ai":"Claude",
+  "copilot.microsoft.com":"Microsoft Copilot",
+  "copilot.com":"Microsoft Copilot",
+  "copilot":"Microsoft Copilot",
+  "deepseek.com":"DeepSeek",
+  "gemini.google.com":"Google Gemini",
+  "grok.com":"Grok",
+  "x.ai":"Grok",
+  "phind.com":"Phind",
+  "chaos.social":"Mastodon",
+  "fosstodon.org":"Mastodon",
+  "hachyderm.io":"Mastodon",
+  "indieweb.social":"Mastodon",
+  "infosec.exchange":"Mastodon",
+  "mas.to":"Mastodon",
+  "mastodon.online":"Mastodon",
+  "mastodon.social":"Mastodon",
+  "mastodon.world":"Mastodon",
+  "mathstodon.xyz":"Mastodon",
+  "mstdn.jp":"Mastodon",
+  "mstdn.social":"Mastodon",
+  "scholar.social":"Mastodon",
+  "sigmoid.social":"Mastodon",
+  "social.tchncs.de":"Mastodon",
+  "android-app://org.joinmastodon.android": "Mastodon",
+  "discord.com":"Discord",
+  "discordapp.com":"Discord",
+  "linktr.ee":"Linktree",
+  "m.sogou.com":"Sogou",
+  "kagi.com":"Kagi",
+  "l.threads.com":"Threads",
+  "ntp.msn.com":"Bing",
+  "perplexity.ai":"Perplexity",
+  "pplx.ai":"Perplexity",
+  "ptb.discord.com":"Discord",
+  "search.brave.com":"Brave",
+  "sogou.com":"Sogou",
+  "statics.teams.cdn.office.net":"Microsoft Teams",
+  "teams.microsoft.com":"Microsoft Teams",
+  "t.me":"Telegram",
+  "wap.sogou.com":"Sogou",
+  "ya.ru":"Yandex",
+  "yandex.com.tr":"Yandex",
+  "yandex.eu":"Yandex",
+  "yandex.fr":"Yandex",
+  "yandex.kz":"Yandex",
+  "yandex.tm":"Yandex",
+  "yandex.uz":"Yandex",
+  "fb": "Facebook",
+  "fb-ads": "Facebook",
+  "fbads": "Facebook",
+  "fbad": "Facebook",
+  "facebook-ads": "Facebook",
+  "facebook_ads": "Facebook",
+  "fcb": "Facebook",
+  "facebook_ad": "Facebook",
+  "facebook_feed_ad": "Facebook",
+  "ig": "Instagram",
+  "yt": "Youtube",
+  "yt-ads": "Youtube",
+  "reddit-ads": "Reddit",
+  "google_ads": "Google",
+  "google-ads": "Google",
+  "googleads": "Google",
+  "gads": "Google",
+  "google ads": "Google",
+  "adwords": "Google",
+  "x.com":"X (Twitter)",
+  "mobile.twitter.com": "X (Twitter)",
+  "twitter-ads": "X (Twitter)",
+  "twitter": "X (Twitter)",
+  "tiktokads": "TikTok",
+  "tik.tok": "TikTok",
+  "wikipedia": "Wikipedia",
+  "canary.discord.com":"Discord",
+  "webk.telegram.org":"Telegram"
+}

priv/data_migrations/AcquisitionChannel/sql/acquisition_channel_add_materialized_column.sql.eex

@@ -0,0 +1,4 @@
+ALTER TABLE <%= @table %>
+<%= @on_cluster_statement %>
+ADD COLUMN IF NOT EXISTS acquisition_channel LowCardinality(String)
+MATERIALIZED acquisition_channel(referrer_source, utm_medium, utm_campaign, utm_source, click_id_param)

priv/data_migrations/AcquisitionChannel/sql/acquisition_channel_backfill_materialized_column.sql.eex

@@ -0,0 +1,2 @@
+ALTER TABLE <%= @table %>
+MATERIALIZE COLUMN acquisition_channel

priv/data_migrations/AcquisitionChannel/sql/acquisition_channel_functions.sql.eex

@@ -0,0 +1,235 @@
+CREATE TABLE IF NOT EXISTS acquisition_channel_source_category
+<%= @on_cluster_statement %>
+(
+    referrer_source String,
+    category LowCardinality(String)
+)
+<%= if @on_cluster_statement != "" do %>
+ENGINE = ReplicatedMergeTree('/clickhouse/{cluster}/tables/{shard}/plausible_prod/acquisition_channel_source_category', '{replica}')
+<% else %>
+ENGINE = MergeTree()
+<% end %>
+ORDER BY referrer_source
+<%= @table_settings %>;
+
+TRUNCATE TABLE acquisition_channel_source_category SETTINGS alter_sync=2;
+
+INSERT INTO acquisition_channel_source_category(referrer_source, category)
+SELECT t.1 AS referrer_source, t.2 AS category
+FROM (
+    SELECT arrayJoin({source_categories:Array(Tuple(String, String))}) AS t
+)
+SETTINGS insert_quorum = <%= @insert_quorum %>;
+
+CREATE OR REPLACE DICTIONARY acquisition_channel_source_category_dict
+<%= @on_cluster_statement %>
+(
+    `referrer_source` String,
+    `category` String
+)
+PRIMARY KEY referrer_source
+SOURCE(CLICKHOUSE(TABLE acquisition_channel_source_category <%= @dictionary_connection_params %>))
+LIFETIME(0)
+LAYOUT(hashed());
+
+CREATE TABLE IF NOT EXISTS acquisition_channel_paid_sources
+<%= @on_cluster_statement %>
+(
+    referrer_source String
+)
+<%= if @on_cluster_statement != "" do %>
+ENGINE = ReplicatedMergeTree('/clickhouse/{cluster}/tables/{shard}/plausible_prod/acquisition_channel_paid_sources', '{replica}')
+<% else %>
+ENGINE = MergeTree()
+<% end %>
+ORDER BY referrer_source
+<%= @table_settings %>;
+
+TRUNCATE TABLE acquisition_channel_paid_sources SETTINGS alter_sync=2;
+
+INSERT INTO acquisition_channel_paid_sources(referrer_source)
+SELECT arrayJoin({paid_sources:Array(String)}) AS referrer_source
+SETTINGS insert_quorum = <%= @insert_quorum %>;
+
+CREATE OR REPLACE DICTIONARY acquisition_channel_paid_sources_dict
+<%= @on_cluster_statement %>
+(
+    `referrer_source` String
+)
+PRIMARY KEY referrer_source
+SOURCE(CLICKHOUSE(TABLE acquisition_channel_paid_sources <%= @dictionary_connection_params %>))
+LIFETIME(0)
+LAYOUT(hashed());
+
+CREATE OR REPLACE FUNCTION acquisition_channel_has_category_shopping <%= @on_cluster_statement %> AS
+(referrer_source) ->
+    dictGet('acquisition_channel_source_category_dict', 'category', referrer_source) = 'SOURCE_CATEGORY_SHOPPING';
+
+CREATE OR REPLACE FUNCTION acquisition_channel_has_category_social <%= @on_cluster_statement %> AS
+(referrer_source) ->
+    dictGet('acquisition_channel_source_category_dict', 'category', referrer_source) = 'SOURCE_CATEGORY_SOCIAL';
+
+CREATE OR REPLACE FUNCTION acquisition_channel_has_category_video <%= @on_cluster_statement %> AS
+(referrer_source) ->
+    dictGet('acquisition_channel_source_category_dict', 'category', referrer_source) = 'SOURCE_CATEGORY_VIDEO';
+
+CREATE OR REPLACE FUNCTION acquisition_channel_has_category_search <%= @on_cluster_statement %> AS
+(referrer_source) ->
+    dictGet('acquisition_channel_source_category_dict', 'category', referrer_source) = 'SOURCE_CATEGORY_SEARCH';
+
+CREATE OR REPLACE FUNCTION acquisition_channel_has_category_email <%= @on_cluster_statement %> AS
+(referrer_source) ->
+    dictGet('acquisition_channel_source_category_dict', 'category', referrer_source) = 'SOURCE_CATEGORY_EMAIL';
+
+CREATE OR REPLACE FUNCTION acquisition_channel_has_category_ai_assistants <%= @on_cluster_statement %> AS
+(referrer_source) ->
+    dictGet('acquisition_channel_source_category_dict', 'category', referrer_source) = 'SOURCE_CATEGORY_AI_ASSISTANTS';
+
+CREATE OR REPLACE FUNCTION acquisition_channel_paid_utm_source <%= @on_cluster_statement %> AS
+(referrer_source) ->
+    dictHas('acquisition_channel_paid_sources_dict', referrer_source);
+
+CREATE OR REPLACE FUNCTION acquisition_channel_cross_network <%= @on_cluster_statement %> AS
+(utm_campaign) ->
+    position(utm_campaign, 'cross-network') > 0;
+
+CREATE OR REPLACE FUNCTION acquisition_channel_paid_shopping <%= @on_cluster_statement %> AS
+(referrer_source, utm_medium, utm_campaign) ->
+    acquisition_channel_paid_medium(utm_medium) AND
+    (
+        acquisition_channel_has_category_shopping(referrer_source)
+        OR acquisition_channel_shopping_campaign(utm_campaign)
+    );
+
+CREATE OR REPLACE FUNCTION acquisition_channel_paid_search <%= @on_cluster_statement %> AS
+(referrer_source, utm_medium, utm_source, click_id_param) ->
+    (
+        acquisition_channel_has_category_search(referrer_source)
+        AND (
+            acquisition_channel_paid_medium(utm_medium)
+            OR acquisition_channel_paid_utm_source(utm_source)
+        )
+    ) OR (
+        referrer_source == 'google'
+        AND click_id_param == 'gclid'
+    ) OR (
+        referrer_source == 'bing'
+        AND click_id_param == 'msclkid'
+    );
+
+CREATE OR REPLACE FUNCTION acquisition_channel_paid_social <%= @on_cluster_statement %> AS
+(referrer_source, utm_medium, utm_source) ->
+    acquisition_channel_has_category_social(referrer_source)
+    AND (
+        acquisition_channel_paid_medium(utm_medium)
+        OR acquisition_channel_paid_utm_source(utm_source)
+    );
+
+CREATE OR REPLACE FUNCTION acquisition_channel_paid_video <%= @on_cluster_statement %> AS
+(referrer_source, utm_medium, utm_source) ->
+    acquisition_channel_has_category_video(referrer_source)
+    AND (
+        acquisition_channel_paid_medium(utm_medium)
+        OR acquisition_channel_paid_utm_source(utm_source)
+    );
+
+CREATE OR REPLACE FUNCTION acquisition_channel_display <%= @on_cluster_statement %> AS
+(utm_medium) ->
+    utm_medium IN ('display', 'banner', 'expandable', 'interstitial', 'cpm');
+
+CREATE OR REPLACE FUNCTION acquisition_channel_paid_medium <%= @on_cluster_statement %> AS
+(utm_medium) ->
+    match(utm_medium, '^(.*cp.*|ppc|retargeting|paid.*)$');
+
+CREATE OR REPLACE FUNCTION acquisition_channel_shopping_campaign <%= @on_cluster_statement %> AS
+(utm_campaign) ->
+    match(utm_campaign, '^(.*(([^a-df-z]|^)shop|shopping).*)$');
+
+CREATE OR REPLACE FUNCTION acquisition_channel_organic_shopping <%= @on_cluster_statement %> AS
+(referrer_source, utm_campaign) ->
+    acquisition_channel_has_category_shopping(referrer_source)
+    OR acquisition_channel_shopping_campaign(utm_campaign);
+
+CREATE OR REPLACE FUNCTION acquisition_channel_organic_social <%= @on_cluster_statement %> AS
+(referrer_source, utm_medium) ->
+    acquisition_channel_has_category_social(referrer_source)
+    OR utm_medium IN (
+        'social',
+        'social-network',
+        'social-media',
+        'sm',
+        'social network',
+        'social media'
+    );
+
+CREATE OR REPLACE FUNCTION acquisition_channel_organic_video <%= @on_cluster_statement %> AS
+(referrer_source, utm_medium) ->
+    acquisition_channel_has_category_video(referrer_source) OR position(utm_medium, 'video') > 0;
+
+CREATE OR REPLACE FUNCTION acquisition_channel_email <%= @on_cluster_statement %> AS
+(referrer_source, utm_source, utm_medium) ->
+   acquisition_channel_has_category_email(referrer_source)
+   OR acquisition_channel_contains_email(utm_source)
+   OR acquisition_channel_contains_email(utm_medium);
+
+CREATE OR REPLACE FUNCTION acquisition_channel_affiliates <%= @on_cluster_statement %> AS
+(utm_medium) ->
+    utm_medium == 'affiliate';
+
+CREATE OR REPLACE FUNCTION acquisition_channel_audio <%= @on_cluster_statement %> AS
+(utm_medium) ->
+    utm_medium == 'audio';
+
+CREATE OR REPLACE FUNCTION acquisition_channel_sms <%= @on_cluster_statement %> AS
+(column) ->
+    column == 'sms';
+
+CREATE OR REPLACE FUNCTION acquisition_channel_mobile_push_notifications <%= @on_cluster_statement %> AS
+(utm_medium, referrer_source) ->
+    endsWith(utm_medium, 'push') OR
+    multiSearchAny(utm_medium, ['mobile', 'notification']) OR
+    referrer_source == 'firebase';
+
+CREATE OR REPLACE FUNCTION acquisition_channel_referral <%= @on_cluster_statement %> AS
+(utm_medium, referrer_source) ->
+    utm_medium IN ('referral', 'app', 'link') OR
+    not empty(referrer_source);
+
+CREATE OR REPLACE FUNCTION acquisition_channel_contains_email <%= @on_cluster_statement %> AS
+(column) ->
+    match(column, 'e[-_ ]?mail|newsletter');
+
+CREATE OR REPLACE FUNCTION acquisition_channel <%= @on_cluster_statement %> AS
+(referrer_source, utm_medium, utm_campaign, utm_source, click_id_param) ->
+    acquisition_channel_lowered(
+        lower(referrer_source),
+        lower(utm_medium),
+        lower(utm_campaign),
+        lower(utm_source),
+        click_id_param
+    );
+
+CREATE OR REPLACE FUNCTION acquisition_channel_lowered <%= @on_cluster_statement %> AS
+(referrer_source, utm_medium, utm_campaign, utm_source, click_id_param) ->
+    multiIf(
+        acquisition_channel_cross_network(utm_campaign), 'Cross-network',
+        acquisition_channel_display(utm_medium), 'Display',
+        acquisition_channel_paid_shopping(referrer_source, utm_medium, utm_campaign), 'Paid Shopping',
+        acquisition_channel_paid_search(referrer_source, utm_medium, utm_source, click_id_param), 'Paid Search',
+        acquisition_channel_paid_social(referrer_source, utm_medium, utm_source), 'Paid Social',
+        acquisition_channel_paid_video(referrer_source, utm_medium, utm_source), 'Paid Video',
+        acquisition_channel_paid_medium(utm_medium), 'Paid Other',
+        acquisition_channel_organic_shopping(referrer_source, utm_campaign), 'Organic Shopping',
+        acquisition_channel_organic_social(referrer_source, utm_medium), 'Organic Social',
+        acquisition_channel_organic_video(referrer_source, utm_medium), 'Organic Video',
+        acquisition_channel_has_category_ai_assistants(referrer_source), 'AI Assistants',
+        acquisition_channel_has_category_search(referrer_source), 'Organic Search',
+        acquisition_channel_email(referrer_source, utm_source, utm_medium), 'Email',
+        acquisition_channel_affiliates(utm_medium), 'Affiliates',
+        acquisition_channel_audio(utm_medium), 'Audio',
+        acquisition_channel_sms(utm_source), 'SMS',
+        acquisition_channel_sms(utm_medium), 'SMS',
+        acquisition_channel_mobile_push_notifications(utm_medium, referrer_source), 'Mobile Push Notifications',
+        acquisition_channel_referral(utm_medium, referrer_source), 'Referral',
+        'Direct'
+    );

priv/data_migrations/AcquisitionChannel/sql/acquisition_channel_update_materialized_column.sql.eex

@@ -0,0 +1,4 @@
+ALTER TABLE <%= @table %>
+<%= @on_cluster_statement %>
+MODIFY COLUMN acquisition_channel LowCardinality(String)
+MATERIALIZED acquisition_channel(referrer_source, utm_medium, utm_campaign, utm_source, click_id_param)

priv/data_migrations/FunnelDupeGoals/sql/list-funnels-with-dupe-goal-ids.sql.eex

@@ -0,0 +1,62 @@
+WITH DuplicateGoals AS (
+	SELECT
+		g.site_id,
+			CASE
+				WHEN g.event_name IS NOT NULL THEN 'Event: ' || g.event_name
+				WHEN g.page_path IS NOT NULL THEN 'Page: ' || g.page_path
+			END AS goal_name,
+		ARRAY_AGG(g.id) AS duplicate_ids
+	FROM
+		goals g
+	WHERE
+		g.site_id IS NOT NULL
+	GROUP BY
+		g.site_id,
+		goal_name
+	HAVING COUNT(*) > 1
+),
+FunnelStepsWithDuplicateGoals AS (
+	SELECT
+		fs.id,
+		fs.goal_id,
+		fs.funnel_id,
+		f.name,
+		CASE
+			WHEN g.event_name IS NOT NULL THEN 'Event: ' || g.event_name
+			WHEN g.page_path IS NOT NULL THEN 'Page: ' || g.page_path
+		END AS goal_name,
+		dg.duplicate_ids
+	FROM
+		funnel_steps fs
+	JOIN goals g ON fs.goal_id = g.id
+	JOIN funnels f ON fs.funnel_id = f.id
+	JOIN DuplicateGoals dg ON f.site_id = dg.site_id
+	WHERE
+		fs.goal_id = ANY(dg.duplicate_ids) -- Ch
+)
+SELECT
+	s.domain,
+	f.site_id,
+	f.name as funnel_name,
+	f.id,
+	fs.id,
+	fs.goal_id,
+	fs.goal_name,
+	fs.duplicate_ids,
+	array_agg(fs2.goal_id)
+FROM
+	funnels f
+JOIN FunnelStepsWithDuplicateGoals fs ON f.id = fs.funnel_id
+JOIN funnel_steps fs2 ON f.id = fs2.funnel_id
+JOIN sites s ON s.id = f.site_id
+GROUP BY
+	s.domain,
+	f.site_id,
+	f.name,
+	f.id,
+	fs.id,
+	fs.goal_id,
+	fs.goal_name,
+	fs.duplicate_ids
+ORDER BY fs.id ASC
+;

priv/data_migrations/LocationsSync/sql/add-alias-column.sql.eex

@@ -0,0 +1,5 @@
+ALTER TABLE <%= @table %>
+<%= if @cluster? do %>ON CLUSTER '{cluster}'<% end %>
+ADD COLUMN IF NOT EXISTS
+<%= @column_name %> String
+ALIAS dictGet('location_data_dict', 'name', tuple('<%= @type %>', <%= @input_column %>))

priv/data_migrations/LocationsSync/sql/create-location-data-table.sql.eex

@@ -0,0 +1,13 @@
+CREATE TABLE IF NOT EXISTS location_data <%= if @cluster? do %>ON CLUSTER '{cluster}'<% end %>
+(
+    `type` LowCardinality(String),
+    `id` String,
+    `name` String
+)
+<%= if @cluster? do %>
+ENGINE = ReplicatedMergeTree('/clickhouse/{cluster}/tables/{shard}/plausible_prod/location_data', '{replica}')
+<% else %>
+ENGINE = MergeTree()
+<% end %>
+ORDER BY (type, id)
+SETTINGS index_granularity = 128 <%= @table_settings %>

priv/data_migrations/LocationsSync/sql/get-location-data-table-comment.sql.eex

@@ -0,0 +1 @@
+select comment from system.tables where database = currentDatabase() and table = 'location_data'

priv/data_migrations/LocationsSync/sql/truncate-location-data-table.sql.eex

@@ -0,0 +1 @@
+TRUNCATE TABLE IF EXISTS location_data SETTINGS alter_sync=2

priv/data_migrations/LocationsSync/sql/update-location-data-dictionary.sql.eex

@@ -0,0 +1,11 @@
+CREATE OR REPLACE DICTIONARY location_data_dict
+<%= if @cluster? do %>ON CLUSTER '{cluster}'<% end %>
+(
+    `type` String,
+    `id` String,
+    `name` String
+)
+PRIMARY KEY type, id
+SOURCE(CLICKHOUSE(TABLE location_data <%= @dictionary_connection_params %>))
+LIFETIME(0)
+LAYOUT(complex_key_cache(size_in_cells 500000))

priv/data_migrations/LocationsSync/sql/update-location-data-table-comment.sql.eex

@@ -0,0 +1,3 @@
+ALTER TABLE location_data
+<%= if @cluster? do %>ON CLUSTER '{cluster}'<% end %>
+MODIFY COMMENT '<%= @version %>'

priv/data_migrations/NumericIDs/sql/attach-tmp-events-v2.sql.eex

@@ -0,0 +1 @@
+ALTER TABLE events_v2 ATTACH PARTITION ID '<%= @partition %>' FROM tmp_events_v2

priv/data_migrations/NumericIDs/sql/attach-tmp-sessions-v2.sql.eex

@@ -0,0 +1 @@
+ALTER TABLE sessions_v2 ATTACH PARTITION ID '<%= @partition %>' FROM tmp_sessions_v2

priv/data_migrations/NumericIDs/sql/check-replicas.sql.eex

@@ -0,0 +1 @@
+SELECT 1 FROM system.replicas WHERE table = 'events'

priv/data_migrations/NumericIDs/sql/create-domains-lookup.sql.eex

@@ -0,0 +1 @@
+CREATE TABLE IF NOT EXISTS domains_lookup(site_id UInt64, domain String) ENGINE Memory;

priv/data_migrations/NumericIDs/sql/create-events-v2.sql.eex

@@ -0,0 +1,39 @@
+CREATE TABLE IF NOT EXISTS events_v2 <%= if @cluster? do %>ON CLUSTER '{cluster}'<% end %>
+(
+    `timestamp` DateTime CODEC(Delta(4), LZ4),
+    `name` LowCardinality(String),
+    `site_id` UInt64,
+    `user_id` UInt64,
+    `session_id` UInt64,
+    `hostname` String,
+    `pathname` String CODEC(ZSTD(3)),
+    `referrer` String,
+    `referrer_source` String,
+    `country_code` FixedString(2),
+    `screen_size` LowCardinality(String),
+    `operating_system` LowCardinality(String),
+    `browser` LowCardinality(String),
+    `utm_medium` String,
+    `utm_source` String,
+    `utm_campaign` String,
+    `meta.key` Array(String),
+    `meta.value` Array(String),
+    `browser_version` LowCardinality(String),
+    `operating_system_version` LowCardinality(String),
+    `subdivision1_code` LowCardinality(String),
+    `subdivision2_code` LowCardinality(String),
+    `city_geoname_id` UInt32,
+    `utm_content` String,
+    `utm_term` String,
+    `transferred_from` String
+)
+<%= if @cluster? do %>
+ENGINE = ReplicatedMergeTree('/clickhouse/{cluster}/tables/{shard}/{database}/events_v2', '{replica}')
+<% else %>
+ENGINE = MergeTree()
+<% end %>
+PARTITION BY toYYYYMM(timestamp)
+PRIMARY KEY (site_id, toDate(timestamp), name, user_id)
+ORDER BY (site_id, toDate(timestamp), name, user_id, timestamp)
+SAMPLE BY user_id
+<%= @table_settings %>

priv/data_migrations/NumericIDs/sql/create-sessions-v2.sql.eex

@@ -0,0 +1,45 @@
+CREATE TABLE IF NOT EXISTS sessions_v2 <%= if @cluster? do %>ON CLUSTER '{cluster}'<% end %>
+(
+    `session_id` UInt64,
+    `sign` Int8,
+    `site_id` UInt64,
+    `user_id` UInt64,
+    `hostname` String,
+    `timestamp` DateTime CODEC(DoubleDelta, LZ4),
+    `start` DateTime CODEC(DoubleDelta, LZ4),
+    `is_bounce` UInt8,
+    `entry_page` String,
+    `exit_page` String,
+    `pageviews` Int32,
+    `events` Int32,
+    `duration` UInt32,
+    `referrer` String,
+    `referrer_source` String,
+    `country_code` LowCardinality(FixedString(2)),
+    `screen_size` LowCardinality(String),
+    `operating_system` LowCardinality(String),
+    `browser` LowCardinality(String),
+    `utm_medium` String,
+    `utm_source` String,
+    `utm_campaign` String,
+    `browser_version` LowCardinality(String),
+    `operating_system_version` LowCardinality(String),
+    `subdivision1_code` LowCardinality(String),
+    `subdivision2_code` LowCardinality(String),
+    `city_geoname_id` UInt32,
+    `utm_content` String,
+    `utm_term` String,
+    `transferred_from` String,
+    `entry_meta.key` Array(String),
+    `entry_meta.value` Array(String)
+)
+<%= if @cluster? do %>
+ENGINE = ReplicatedCollapsingMergeTree('/clickhouse/{cluster}/tables/{shard}/plausible_prod/sessions_v2', '{replica}', sign)
+<% else %>
+ENGINE = CollapsingMergeTree(sign)
+<% end %>
+PARTITION BY toYYYYMM(start)
+PRIMARY KEY (site_id, toDate(start), user_id, session_id)
+ORDER BY (site_id, toDate(start), user_id, session_id)
+SAMPLE BY user_id
+<%= @table_settings %>

priv/data_migrations/NumericIDs/sql/create-tmp-events-v2.sql.eex

@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS
+    tmp_events_v2 AS events_v2 ENGINE = MergeTree()
+    ORDER BY (site_id, toDate(timestamp), name, user_id, timestamp)
+    PRIMARY KEY (site_id, toDate(timestamp), name, user_id)
+    PARTITION BY toYYYYMM(timestamp)
+    <%= @table_settings %>

priv/data_migrations/NumericIDs/sql/create-tmp-sessions-v2.sql.eex

@@ -0,0 +1,6 @@
+CREATE TABLE IF NOT EXISTS
+    tmp_sessions_v2 AS sessions_v2 ENGINE = CollapsingMergeTree(sign)
+    PARTITION BY toYYYYMM(start)
+    PRIMARY KEY (site_id, toDate(start), user_id, session_id)
+    ORDER BY (site_id, toDate(start), user_id, session_id)
+    <%= @table_settings %>

priv/data_migrations/NumericIDs/sql/drop-domains-lookup.sql.eex

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS domains_lookup SYNC;