Random via cached ID

The easiest way to work with random values is to call `order("RANDOM()")` but this is very bad for database performance. There's hacks to get faster lookups but they all come with caveats. Mostly in terms of guarantees, either they'll return no data, or less than the data you want. You've got to  retry queries, but if you do that in an unbounded way then you might end up an an infinite loop.

This approach attempts to give the maximum flexibility of full order("random()") but with non-awful performance. The cost here is that the values persist for the given time frame. Also since we're still using `order("RANDOM()")` the first query is still expensive.

It works like this: The SQL of the query is used to generate a cache key. The query is then made and the resulting IDs are returned. Then those IDs are used to query the original model.

I'm still not in love with it, but it's okay for now.

I think for more complex logic there's got to be a better way to handle this kind of processing. But 🤷‍♂️

Author: schneems

app/mailers/user_mailer.rb

@@ -77,17 +77,20 @@ def send_triage(user:, assignment:, repo:, create: false)
 
   def poke_inactive(user:, min_issue_count:, min_subscriber_count:)
     return unless set_and_check_user(user)
+    languages = @user.favorite_languages&.sort || []
 
-    if @user.favorite_languages.present?
-      @repos = Repo.where(language: favorite_languages)
-    else
-      @repos = Repo
-    end
+    query = Repo
+    query = repo.where(language: languages) if !languages.empty?
+    query = query
+            .where("issues_count >= ?", min_issue_count)
+            .where("subscribers_count >= ?", min_subscriber_count)
+
+    @repos = Random::CachedIdQuery.new(
+      query: query,
+      limit: 3,
+      expires_in: 24.hours
+    ).call
 
-    @repos = @repos
-             .rand
-             .where("issues_count >= ?", min_issue_count)
-             .where("subscribers_count >= ?", min_subscriber_count).first(3)
     mail(to: @user.email, reply_to: "[email protected]", subject: "CodeTriage misses you")
   end
 

app/models/random/cached_id_query.rb

@@ -0,0 +1,30 @@
+# Provides an actual random result exactly as expected
+# but it's cached for a period of time.
+#
+# Cache keys expire after the set time but
+# are unbounded. Take care to not pass in arbitrary data
+# from users into the query.
+#
+# The raw SQL is used for a cache key so take care
+# to pass in values in sorted order etc.
+#
+# The first run of this is VERY expensive on a large
+# model and can still cause significant database load
+class Random::CachedIdQuery
+  private attr_reader :limit, :query, :key, :expires_in
+
+  def initialize(query:, limit:, expires_in:)
+    @query = query.order("RANDOM()")
+    @key = "random_cached_query:#{@query.to_sql.hash}"
+    @expires_in = expires_in
+    @limit = limit
+  end
+
+  def call
+    ids = Rails.cache.fetch(key, expires_in: expires_in) do
+      query.select(:id).first(limit).map(&:id)
+    end
+
+    query.klass.where(id: ids)
+  end
+end

app/models/repo.rb

@@ -131,13 +131,6 @@ def self.not_in(*ids)
     where("repos.id not in (?)", ids)
   end
 
-  @@max_id = nil
-  def self.rand
-    @@max_id = self.maximum(:id) if @@max_id.nil?
-
-    where("id >= ?", Random.new.rand(1..@@max_id))
-  end
-
   def self.all_languages
     self.select("language").group("language").order("language ASC").map(&:language).reject(&:blank?)
   end