Execute some analytics-related inserts async in postgres (forem#22748)

* Execute some analytics-related inserts async in postgres

* Add comment

Author: benhalpern

app/controllers/billboard_events_controller.rb

@@ -6,7 +6,9 @@ class BillboardEventsController < ApplicationMetalController
   def create
     # Only tracking for logged‐in users at the moment
     billboard_event_create_params = billboard_event_params.merge(user_id: session_current_user_id)
-    @billboard_event = BillboardEvent.create(billboard_event_create_params)
+    @billboard_event = ApplicationRecord.with_synchronous_commit_off do
+      BillboardEvent.create(billboard_event_create_params)
+    end
 
     unless ApplicationConfig["DISABLE_BILLBOARD_DATA_UPDATE"] == "yes"
       # Enqueue the worker instead of doing the update inline

app/models/application_record.rb

@@ -62,6 +62,14 @@ def self.with_statement_timeout(duration, connection: self.connection)
     connection.execute "SET statement_timeout = #{milliseconds}"
   end
 
+  # Used for high-volume inserts to prevent unnecessary locking and blocking of other operations
+  def self.with_synchronous_commit_off
+    transaction do
+      connection.execute("SET LOCAL synchronous_commit TO OFF")
+      yield
+    end
+  end
+
   # ActiveRecord's `find_each` method allows you to work with a large collection of records
   # in batches, but strictly only orders those batches by IDs in ascending order.
   # Any other specified order is either ignored or raises an error (depending on configuration).

app/workers/billboards/track_email_click_worker.rb

@@ -13,11 +13,13 @@ def perform(bb_param, user_id)
     private
 
     def track_billboard
-      BillboardEvent.create(billboard_id: @bb.to_i,
-                            category: "click",
-                            user_id: @user&.id,
-                            context_type: "email")
-      update_billboard_counts
+      ApplicationRecord.with_synchronous_commit_off do
+        BillboardEvent.create(billboard_id: @bb.to_i,
+                              category: "click",
+                              user_id: @user&.id,
+                              context_type: "email")
+        update_billboard_counts
+      end
     rescue StandardError => e
       Rails.logger.error "Error processing billboard click: #{e.message}"
     end

app/workers/emails/send_user_digest_worker.rb

@@ -43,9 +43,15 @@ def perform(user_id, force_send = false)
         )
           .digest_email.deliver_now
 
-        event_params = { user_id: user.id, context_type: "email", category: "impression" }
-        BillboardEvent.create(event_params.merge(billboard_id: first_billboard.id)) if first_billboard.present?
-        BillboardEvent.create(event_params.merge(billboard_id: second_billboard.id)) if second_billboard.present?
+        # Track billboard impressions with relaxed durability — these are
+        # low-priority analytics writes that don't need synchronous WAL flush.
+        if first_billboard.present? || second_billboard.present?
+          event_params = { user_id: user.id, context_type: "email", category: "impression" }
+          ApplicationRecord.with_synchronous_commit_off do
+            BillboardEvent.create(event_params.merge(billboard_id: first_billboard.id)) if first_billboard.present?
+            BillboardEvent.create(event_params.merge(billboard_id: second_billboard.id)) if second_billboard.present?
+          end
+        end
       rescue StandardError => e
         Honeybadger.context({ user_id: user.id, article_ids: articles.map(&:id) })
         Honeybadger.notify(e)

spec/workers/emails/batch_custom_send_worker_spec.rb

@@ -32,6 +32,11 @@
         expect(CustomMailer).to have_received(:with).twice
       end
 
+      it "does not wrap email delivery in a synchronous_commit_off transaction" do
+        expect(ApplicationRecord).not_to receive(:with_synchronous_commit_off)
+        worker.perform(user_ids, subject_line, content, type_of, email_id)
+      end
+
       it "logs an error and continues if one user raises an exception" do
         allow(User).to receive(:find_by).with(id: user.id).and_return(user)
         allow(User).to receive(:find_by).with(id: user2.id).and_raise(StandardError.new("Boom!"))

spec/workers/emails/drip_email_worker_spec.rb

@@ -111,6 +111,11 @@
       ).once
     end
 
+    it "does not wrap email delivery in a synchronous_commit_off transaction" do
+      expect(ApplicationRecord).not_to receive(:with_synchronous_commit_off)
+      worker.perform
+    end
+
     it "sends custom template to users with their own onboarding_subforem_id" do
       worker.perform
       expect(CustomMailer).to have_received(:with).with(

spec/workers/emails/send_user_digest_worker_spec.rb

@@ -87,6 +87,31 @@
         expect(BillboardEvent.where(billboard_id: bb_2.id, category: "impression").size).to be(1)
       end
 
+      it "still delivers email even if billboard event creation raises" do
+        create_list(:article, 3, user_id: author.id, public_reactions_count: 20, score: 20, tag_list: [tag.name])
+        create(:billboard, placement_area: "digest_first", published: true, approved: true)
+
+        allow(BillboardEvent).to receive(:create).and_raise(StandardError.new("DB error"))
+        allow(Honeybadger).to receive(:context)
+        allow(Honeybadger).to receive(:notify)
+
+        worker.perform(user.id)
+
+        # Email was already delivered before billboard tracking was attempted
+        expect(message_delivery).to have_received(:deliver_now)
+        expect(Honeybadger).to have_received(:notify).with(instance_of(StandardError))
+      end
+
+      it "does not open a transaction when no billboards are present" do
+        create_list(:article, 3, user_id: author.id, public_reactions_count: 20, score: 20, tag_list: [tag.name])
+
+        expect(ApplicationRecord).not_to receive(:with_synchronous_commit_off)
+
+        worker.perform(user.id)
+
+        expect(message_delivery).to have_received(:deliver_now)
+      end
+
       context "when there's a preferred paired billboard" do
         let!(:bb_1) do
           create(