git.squeep.com Git - akkoma/blob - benchmarks/mix/tasks/pleroma/benchmarks/tags.ex

   1 defmodule Mix.Tasks.Pleroma.Benchmarks.Tags do
   2   use Mix.Task
   3
   4   import Pleroma.LoadTesting.Helper, only: [clean_tables: 0]
   5   import Ecto.Query
   6
   7   alias Pleroma.Repo
   8
   9   def run(_args) do
  10     Mix.Pleroma.start_pleroma()
  11     activities_count = Repo.aggregate(from(a in Pleroma.Activity), :count, :id)
  12
  13     if activities_count == 0 do
  14       IO.puts("Did not find any activities, cleaning and generating")
  15       clean_tables()
  16       Pleroma.LoadTesting.Users.generate_users(10)
  17       Pleroma.LoadTesting.Activities.generate_tagged_activities()
  18     else
  19       IO.puts("Found #{activities_count} activities, won't generate new ones")
  20     end
  21
  22     tags = Enum.map(0..20, fn i -> {"For #tag_#{i}", "tag_#{i}"} end)
  23
  24     Enum.each(tags, fn {_, tag} ->
  25       query =
  26         from(o in Pleroma.Object,
  27           where: fragment("(?)->'tag' \\? (?)", o.data, ^tag)
  28         )
  29
  30       count = Repo.aggregate(query, :count, :id)
  31       IO.puts("Database contains #{count} posts tagged with #{tag}")
  32     end)
  33
  34     user = Repo.all(Pleroma.User) |> List.first()
  35
  36     Benchee.run(
  37       %{
  38         "Hashtag fetching, any" => fn tags ->
  39           hashtag_fetching(
  40             %{
  41               "any" => tags
  42             },
  43             user,
  44             false
  45           )
  46         end,
  47         # Will always return zero results because no overlapping hashtags are generated.
  48         "Hashtag fetching, all" => fn tags ->
  49           hashtag_fetching(
  50             %{
  51               "all" => tags
  52             },
  53             user,
  54             false
  55           )
  56         end
  57       },
  58       inputs:
  59         tags
  60         |> Enum.map(fn {_, v} -> v end)
  61         |> Enum.chunk_every(2)
  62         |> Enum.map(fn tags -> {"For #{inspect(tags)}", tags} end),
  63       time: 5
  64     )
  65
  66     Benchee.run(
  67       %{
  68         "Hashtag fetching" => fn tag ->
  69           hashtag_fetching(
  70             %{
  71               "tag" => tag
  72             },
  73             user,
  74             false
  75           )
  76         end
  77       },
  78       inputs: tags,
  79       time: 5
  80     )
  81   end
  82
  83   defp hashtag_fetching(params, user, local_only) do
  84     tags =
  85       [params["tag"], params["any"]]
  86       |> List.flatten()
  87       |> Enum.uniq()
  88       |> Enum.filter(& &1)
  89       |> Enum.map(&String.downcase(&1))
  90
  91     tag_all =
  92       params
  93       |> Map.get("all", [])
  94       |> Enum.map(&String.downcase(&1))
  95
  96     tag_reject =
  97       params
  98       |> Map.get("none", [])
  99       |> Enum.map(&String.downcase(&1))
 100
 101     _activities =
 102       %{
 103         type: "Create",
 104         local_only: local_only,
 105         blocking_user: user,
 106         muting_user: user,
 107         user: user,
 108         tag: tags,
 109         tag_all: tag_all,
 110         tag_reject: tag_reject,
 111       }
 112       |> Pleroma.Web.ActivityPub.ActivityPub.fetch_public_activities()
 113   end
 114 end