Tweak caching + apply worker improvements from other branch

Author: Ameobea

backend/app/helpers/application_helper.rb

@@ -29,39 +29,26 @@ def with_cache(hash_name, key, json: true)
 
     # If the cache value is currently being computed, we bail out early and expect the client to
     # re-request in a bit.
-    #
-    # If the value has been computing for longer than the cutoff, we assume the old computation
-    # failed and compute it ourselves
-    is_recomputing = false
-    if cached
-      if cached.start_with? "__computing__"
-        date_string = cached.split("__computing__")[1]
-        date = Date.parse(date_string)
-
-        if date < 3.minute.ago.utc
-          raise ApplicationController::LockError
-        else
-          is_recomputing = true
-        end
-      else
-        return cached
-      end
+    if cached && !cached.start_with?("__computing__")
+      return cached
     end
+    # If the value is currently being computed, we fall back to trying to acquire the lock and then
+    # return the value from there once we have it.
 
     # Lock the cache entry that we're trying to write to in order to ensure that we're not
     # computing the same expensive value that some other worker is already computing
     lock_key = "#{hash_name}_#{key}"
     ret = nil
-    $lock_manager.lock(lock_key, 18502) do |locked|
+    $lock_manager.lock(lock_key, 240000) do |locked|
       if locked
         begin
           # It's possible someone else was computing this while we were waiting for the lock.  If so, we
           # just return that and avoid re-computing
           refreshed_cached = get_cache hash_name, key
 
           if cached != refreshed_cached
-            if refreshed_cached.starts_with? "__computing__"
-              # Someone else beat us to the lock and is re-computing the value, so we just let them do it
+            if refreshed_cached.starts_with?("__computing__")
+              # The 4-minute window for computing that value has expired since their lock ran out.  Maybe
               $lock_manager.unlock(locked)
               raise ApplicationController::LockError
             end
@@ -72,14 +59,14 @@ def with_cache(hash_name, key, json: true)
           end
 
           # Create a placeholder value in the cache indicating that the value is currently being computed
-          # and when the computation started
-          now = Time.new
-          date_string = now.strftime("%Y-%m-%d %H:%M:%S")
-          placeholder_val = "__computing__#{date_string}"
-          put_cache hash_name, key, placeholder_val, false
+          #
+          # We have exclusive access to this cache entry currently.
+          put_cache hash_name, key, "__computing__", false
 
           # Compute the new value while holding the lock, set it in the cache, and then drop the lock
           ret = put_cache hash_name, key, yield, json
+          $lock_manager.unlock(locked)
+          next
         rescue ApplicationController::NotFound
           delete_cache hash_name, key
           $lock_manager.unlock(locked)
@@ -93,7 +80,6 @@ def with_cache(hash_name, key, json: true)
         end
       else
         p "Failed to acquire a lock for key #{lock_key} in the timeout period"
-        $lock_manager.unlock(locked)
         raise ApplicationController::LockError
       end
     end

backend/config/environments/development.rb

@@ -27,6 +27,8 @@
     config.cache_store = :null_store
   end
 
+  config.allow_concurrency = true
+
   # Store uploaded files on the local file system (see config/storage.yml for options)
   # config.active_storage.service = :local
 

backend/config/initializers/mongo.rb

@@ -5,4 +5,4 @@
   Mongo::Logger.level = Logger::FATAL
 end
 
-::MongoClient = Mongo::Client.new(["#{host}:#{port}"], database: "robinhood")
+::MongoClient = Mongo::Client.new(["#{host}:#{port}"], database: "robinhood", max_pool_size: 20)

backend/config/puma.rb

@@ -6,6 +6,7 @@
 #
 threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 }
 threads threads_count, threads_count
+workers ENV.fetch("WEB_CONCURRENCY") { 6 }
 
 # Specifies the `port` that Puma will listen on to receive requests; default is 3000.
 #
@@ -27,8 +28,13 @@
 # This directive tells Puma to first boot the application and load code
 # before forking the application. This takes advantage of Copy On Write
 # process behavior so workers use less memory.
-#
-# preload_app!
+
+preload_app!
+
+on_worker_boot do
+  MongoClient.close
+  MongoClient.reconnect
+end
 
 # Allow puma to be restarted by `rails restart` command.
 plugin :tmp_restart