A platform for community discussion. Free, open, simple.
PERF: Batch `BrowserPageviewEvent` inserts through Redis (#40328)
Krzysztof Kotlarekfe862e093118
diff --git a/app/jobs/scheduled/flush_browser_pageview_events.rb b/app/jobs/scheduled/flush_browser_pageview_events.rbnew file mode 100644index 00000000000..80ac34ea68b--- /dev/null+++ b/app/jobs/scheduled/flush_browser_pageview_events.rb@@ -0,0 +1,24 @@+# frozen_string_literal: true++module Jobs+ class FlushBrowserPageviewEvents < ::Jobs::Scheduled+ every 5.minutes++ MAX_FLUSH_SECONDS = 50++ def execute(args)+ return if !SiteSetting.persist_browser_pageview_events+ return if Discourse.pg_readonly_mode?++ deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + MAX_FLUSH_SECONDS++ loop do+ return if BrowserPageviewEvent.queued_count == 0++ processed = BrowserPageviewEvent.flush_queued!+ return if processed < BrowserPageviewEvent::REDIS_FLUSH_BATCH_SIZE+ return if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline+ end+ end+ end+enddiff --git a/app/models/browser_pageview_event.rb b/app/models/browser_pageview_event.rbindex 6499a650bff..d20531a2494 100644--- a/app/models/browser_pageview_event.rb+++ b/app/models/browser_pageview_event.rb@@ -7,6 +7,175 @@ class BrowserPageviewEvent < ActiveRecord::BaseMAX_USER_AGENT_LENGTH = 1000MAX_NORMALIZED_REFERRER_LENGTH = 2000RETENTION_PERIOD = 3.months+ REDIS_QUEUE_KEY = "browser_pageview_events:pending"+ REDIS_FLUSH_LOCK_KEY = "browser_pageview_events:flush"+ REDIS_FLUSH_BATCH_SIZE = 1000+ REDIS_QUEUE_MAX_SIZE = 1_000_000+ REDIS_QUEUE_TTL = 1.day++ class << self+ def enqueue_for_later(payload)+ return unless valid_payload?(payload)+ return if Discourse.redis.llen(REDIS_QUEUE_KEY) >= REDIS_QUEUE_MAX_SIZE++ Discourse.redis.multi do |transaction|+ transaction.rpush(REDIS_QUEUE_KEY, JSON.generate(serialize_payload(payload)))+ transaction.expire(REDIS_QUEUE_KEY, REDIS_QUEUE_TTL)+ end+ rescue Redis::BaseConnectionError => e+ Rails.logger.warn("Failed to queue BrowserPageviewEvent in Redis: #{e.message}")+ end++ def create_from_payload!(payload)+ BrowserPageviewEvent.create!(attributes_from_payload(payload))+ end++ def flush_queued!+ return 0 if Discourse.pg_readonly_mode?++ processed = 0++ DistributedMutex.synchronize(REDIS_FLUSH_LOCK_KEY, validity: 5.minutes) do+ entries = Array(Discourse.redis.lrange(REDIS_QUEUE_KEY, 0, REDIS_FLUSH_BATCH_SIZE - 1))+ queued_attributes = []++ entries.each do |entry|+ queued_attributes << attributes_from_payload(deserialize_payload(entry))+ processed += 1+ rescue => e+ Rails.logger.error("Discarding queued BrowserPageviewEvent: #{e.message}")+ queued_attributes << nil+ processed += 1+ end++ begin+ insert_rows!(queued_attributes)+ rescue ActiveRecord::ReadOnlyError+ Discourse.received_postgres_readonly!+ return 0+ rescue ActiveRecord::StatementInvalid => e+ if postgres_readonly_error?(e)+ Discourse.received_postgres_readonly!+ return 0+ end++ return 0 if postgres_connection_error?(e)++ Rails.logger.error("Failed to insert queued BrowserPageviewEvents: #{e.message}")+ return 0+ end+ end++ processed+ end++ def queued_count+ Discourse.redis.llen(REDIS_QUEUE_KEY).to_i+ end++ def clear_queued!+ Discourse.redis.del(REDIS_QUEUE_KEY)+ end++ def postgres_readonly_error?(error)+ error.cause.is_a?(PG::ReadOnlySqlTransaction)+ end++ private++ def insert_rows!(queued_attributes)+ return if queued_attributes.blank?++ rows = queued_attributes.compact+ if rows.present?+ BrowserPageviewEvent.transaction(requires_new: true) do+ BrowserPageviewEvent.insert_all(rows, returning: false)+ end+ end+ Discourse.redis.ltrim(REDIS_QUEUE_KEY, queued_attributes.length, -1)+ rescue ActiveRecord::StatementInvalid => e+ Rails.logger.error(+ "Failed to insert queued BrowserPageviewEvents in bulk; retrying individually: #{e.message}",+ )+ insert_rows_individually!(queued_attributes)+ end++ def insert_rows_individually!(queued_attributes)+ queued_attributes.each do |attributes|+ if attributes+ BrowserPageviewEvent.transaction(requires_new: true) do+ BrowserPageviewEvent.insert_all([attributes], returning: false)+ end+ end+ Discourse.redis.ltrim(REDIS_QUEUE_KEY, 1, -1)+ rescue ActiveRecord::StatementInvalid => e+ raise if postgres_readonly_error?(e) || postgres_connection_error?(e)++ Rails.logger.error(+ "Discarding queued BrowserPageviewEvent after insert failure: #{e.message}",+ )+ Discourse.redis.ltrim(REDIS_QUEUE_KEY, 1, -1)+ end+ end++ def serialize_payload(payload)+ payload = payload.with_indifferent_access++ {+ user_id: payload[:user_id],+ url: payload[:url]&.slice(0, MAX_URL_LENGTH),+ ip_address: payload[:ip_address],+ country_code: payload[:country_code]&.slice(0, 2),+ asn: payload[:asn],+ referrer: payload[:referrer]&.slice(0, MAX_REFERRER_LENGTH),+ user_agent: payload[:user_agent]&.slice(0, MAX_USER_AGENT_LENGTH),+ session_id: payload[:session_id]&.slice(0, MAX_SESSION_ID_LENGTH),+ topic_id: payload[:topic_id],+ occurred_at: payload[:occurred_at],+ }+ end++ def deserialize_payload(entry)+ JSON.parse(entry).with_indifferent_access+ end++ def attributes_from_payload(payload)+ normalized_referrer = BrowserPageviewReferrerInspector.normalize(payload[:referrer])++ {+ url: payload[:url]&.slice(0, MAX_URL_LENGTH),+ ip_address: payload[:ip_address],+ country_code: payload[:country_code]&.slice(0, 2),+ asn: payload[:asn],+ referrer: payload[:referrer]&.slice(0, MAX_REFERRER_LENGTH),+ normalized_referrer: normalized_referrer&.slice(0, MAX_NORMALIZED_REFERRER_LENGTH),+ normalized_referrer_version: BrowserPageviewReferrerInspector::VERSION,+ user_agent: payload[:user_agent]&.slice(0, MAX_USER_AGENT_LENGTH),+ session_id: payload[:session_id]&.slice(0, MAX_SESSION_ID_LENGTH),+ user_id: payload[:user_id],+ topic_id: payload[:topic_id],+ created_at: payload[:occurred_at],+ }+ end++ def valid_payload?(payload)+ payload[:url].present? && payload[:ip_address].present? && payload[:user_agent].present? &&+ payload[:session_id].present? && payload[:occurred_at].present? &&+ valid_ip_address?(payload[:ip_address])+ end++ def valid_ip_address?(ip_address)+ IPAddr.new(ip_address)+ true+ rescue IPAddr::Error+ false+ end++ def postgres_connection_error?(error)+ cause = error.cause+ cause.is_a?(PG::ConnectionBad) || cause.is_a?(PG::UnableToSend)+ end+ endhas_one :browser_pageview_event_score, foreign_key: :event_id, dependent: :deletediff --git a/lib/middleware/request_tracker.rb b/lib/middleware/request_tracker.rbindex 299dee4e099..0c08a15cac6 100644--- a/lib/middleware/request_tracker.rb+++ b/lib/middleware/request_tracker.rb@@ -143,7 +143,6 @@ class Middleware::RequestTrackerApplicationRequest.increment!(:page_view_anon_browser)ApplicationRequest.increment!(:page_view_anon_browser_mobile) if data[:is_mobile]end- trigger_browser_pageview_event(data)endif data[:topic_id].present? && (!data[:has_auth_cookie] || data[:current_user_id].present?) &&@@ -420,8 +419,11 @@ class Middleware::RequestTrackerdef log_later(data, env, request)Scheduler::Defer.later("Track view") do- unless Discourse.pg_readonly_mode?+ if Discourse.pg_readonly_mode?+ self.class.track_browser_pageview(data) if SiteSetting.persist_browser_pageview_events+ elseself.class.log_request(data)+ self.class.track_browser_pageview(data)instrument_browser_page_view(env, request, data)endrescue ActiveRecord::ReadOnlyError@@ -712,14 +714,16 @@ class Middleware::RequestTrackerendprivate_class_method :extract_beacon_view_tracking_data- def self.trigger_browser_pageview_event(data)+ def self.track_browser_pageview(data)+ return if data[:is_beacon]+ return if !tracks_browser_page_view?(data)+if SiteSetting.persist_browser_pageview_eventspersist_browser_pageview_event(build_browser_pageview_event_payload(data))elsif SiteSetting.trigger_browser_pageview_eventsDiscourseEvent.trigger(:browser_pageview, build_browser_pageview_event_payload(data))endend- private_class_method :trigger_browser_pageview_eventdef self.persist_browser_pageview_event(payload)if REQUIRED_BROWSER_PAGEVIEW_EVENT_FIELDS.any? { |key| payload[key].blank? }@@ -728,23 +732,18 @@ class Middleware::RequestTrackerendScheduler::Defer.later "Create BrowserPageviewEvent" do- BrowserPageviewEvent.create!(- url: payload[:url],- ip_address: payload[:ip_address],- country_code: payload[:country_code],- asn: payload[:asn],- referrer: payload[:referrer],- normalized_referrer: BrowserPageviewReferrerInspector.normalize(payload[:referrer]),- normalized_referrer_version: BrowserPageviewReferrerInspector::VERSION,- user_agent: payload[:user_agent],- session_id: payload[:session_id],- user_id: payload[:user_id],- topic_id: payload[:topic_id],- created_at: payload[:occurred_at],- )+ if Discourse.pg_readonly_mode?+ queue_browser_pageview_event(payload)+ else+ BrowserPageviewEvent.create_from_payload!(payload)+ end+ rescue ActiveRecord::ReadOnlyError+ Discourse.received_postgres_readonly!+ queue_browser_pageview_event(payload)rescue ActiveRecord::StatementInvalid => e- if e.cause.is_a?(PG::ReadOnlySqlTransaction)- # Skip recording browser pageviews when PostgreSQL is in read-only transaction mode.+ if BrowserPageviewEvent.postgres_readonly_error?(e)+ Discourse.received_postgres_readonly!+ queue_browser_pageview_event(payload)elsif e.cause.is_a?(PG::NotNullViolation) && e.cause.message.include?("ip_address")Rails.logger.debug("Discarding BrowserPageviewEvent: invalid IP #{payload[:ip_address]}")else@@ -758,6 +757,13 @@ class Middleware::RequestTrackerendprivate_class_method :persist_browser_pageview_event+ def self.queue_browser_pageview_event(payload)+ BrowserPageviewEvent.enqueue_for_later(+ payload.merge(occurred_at: payload[:occurred_at].iso8601(6)),+ )+ end+ private_class_method :queue_browser_pageview_event+def self.trigger_beacon_browser_pageview_event(data)if SiteSetting.trigger_browser_pageview_eventsDiscourseEvent.trigger(:beacon_browser_pageview, build_browser_pageview_event_payload(data))diff --git a/spec/jobs/flush_browser_pageview_events_spec.rb b/spec/jobs/flush_browser_pageview_events_spec.rbnew file mode 100644index 00000000000..e79e1feabbe--- /dev/null+++ b/spec/jobs/flush_browser_pageview_events_spec.rb@@ -0,0 +1,64 @@+# frozen_string_literal: true++RSpec.describe Jobs::FlushBrowserPageviewEvents do+ before do+ BrowserPageviewEvent.clear_queued!+ Discourse.clear_readonly!+ end++ after do+ BrowserPageviewEvent.clear_queued!+ Discourse.clear_readonly!+ end++ let(:payload) do+ {+ url: "https://discourse.example/t/topic/1",+ ip_address: "1.2.3.4",+ user_agent: "Mozilla/5.0",+ session_id: "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx",+ occurred_at: Time.zone.parse("2026-05-27 10:30:00").iso8601(6),+ }+ end++ def queue_payload(payload)+ BrowserPageviewEvent.enqueue_for_later(payload)+ end++ def queue_payloads(payloads)+ payloads.each { |queued_payload| queue_payload(queued_payload) }+ end++ it "does nothing when browser pageview persistence is disabled" do+ SiteSetting.persist_browser_pageview_events = false+ queue_payload(payload)++ expect { described_class.new.execute({}) }.not_to change { BrowserPageviewEvent.count }++ expect(BrowserPageviewEvent.queued_count).to eq(1)+ end++ it "flushes queued browser pageviews" do+ SiteSetting.persist_browser_pageview_events = true+ queue_payload(payload)++ expect { described_class.new.execute({}) }.to change { BrowserPageviewEvent.count }.by(1)++ expect(BrowserPageviewEvent.queued_count).to eq(0)+ end++ it "flushes multiple batches in one run" do+ SiteSetting.persist_browser_pageview_events = true++ stub_const(BrowserPageviewEvent, "REDIS_FLUSH_BATCH_SIZE", 3) do+ payloads = 5.times.map { |index| payload.merge(session_id: format("%032d", index)) }+ queue_payloads(payloads)++ expect { described_class.new.execute({}) }.to change { BrowserPageviewEvent.count }.by(+ payloads.length,+ )++ expect(BrowserPageviewEvent.queued_count).to eq(0)+ end+ end+enddiff --git a/spec/lib/middleware/request_tracker_spec.rb b/spec/lib/middleware/request_tracker_spec.rbindex 805b90fb9b0..4003b7192b3 100644--- a/spec/lib/middleware/request_tracker_spec.rb+++ b/spec/lib/middleware/request_tracker_spec.rb@@ -731,6 +731,10 @@ RSpec.describe Middleware::RequestTracker doenddescribe "browser_pageview event" do+ def log_browser_pageview(data)+ Middleware::RequestTracker.new(lambda { |env| [200, {}, ["OK"]] }).log_later(data, {}, nil)+ end+context "when SiteSetting.trigger_browser_pageview_events is true" dobefore { SiteSetting.trigger_browser_pageview_events = true }it "triggers event for anonymous user page views when `login_required` site setting is false" do@@ -749,10 +753,7 @@ RSpec.describe Middleware::RequestTracker do0.2,)- events =- DiscourseEvent.track_events(:browser_pageview) do- Middleware::RequestTracker.log_request(data)- end+ events = DiscourseEvent.track_events(:browser_pageview) { log_browser_pageview(data) }expect(events.length).to eq(1)event = events[0][:params].first@@ -781,10 +782,7 @@ RSpec.describe Middleware::RequestTracker do0.2,)- events =- DiscourseEvent.track_events(:browser_pageview) do- Middleware::RequestTracker.log_request(data)- end+ events = DiscourseEvent.track_events(:browser_pageview) { log_browser_pageview(data) }expect(events).to be_emptyend@@ -805,10 +803,7 @@ RSpec.describe Middleware::RequestTracker do0.2,)- events =- DiscourseEvent.track_events(:browser_pageview) do- Middleware::RequestTracker.log_request(data)- end+ events = DiscourseEvent.track_events(:browser_pageview) { log_browser_pageview(data) }expect(events.length).to eq(1)event = events[0][:params].first@@ -843,10 +838,7 @@ RSpec.describe Middleware::RequestTracker do0.2,)- events =- DiscourseEvent.track_events(:browser_pageview) do- Middleware::RequestTracker.log_request(data)- end+ events = DiscourseEvent.track_events(:browser_pageview) { log_browser_pageview(data) }expect(events.length).to eq(1)event = events[0][:params].first@@ -866,10 +858,7 @@ RSpec.describe Middleware::RequestTracker do0.2,)- events =- DiscourseEvent.track_events(:browser_pageview) do- Middleware::RequestTracker.log_request(data)- end+ events = DiscourseEvent.track_events(:browser_pageview) { log_browser_pageview(data) }expect(events.length).to eq(0)end@@ -891,17 +880,27 @@ RSpec.describe Middleware::RequestTracker do0.2,)- events =- DiscourseEvent.track_events(:browser_pageview) do- Middleware::RequestTracker.log_request(data)- end+ events = DiscourseEvent.track_events(:browser_pageview) { log_browser_pageview(data) }expect(events.length).to eq(0)endendcontext "when SiteSetting.persist_browser_pageview_events is true" do- before { SiteSetting.persist_browser_pageview_events = true }+ before do+ SiteSetting.persist_browser_pageview_events = true+ BrowserPageviewEvent.clear_queued!+ Discourse.clear_readonly!+ end++ after do+ BrowserPageviewEvent.clear_queued!+ Discourse.clear_readonly!+ end++ def flush_browser_pageview_events+ Jobs::FlushBrowserPageviewEvents.new.execute({})+ endit "creates a BrowserPageviewEvent row and does not fire the :browser_pageview event" dosession_id = "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx"@@ -922,12 +921,11 @@ RSpec.describe Middleware::RequestTracker doevents =DiscourseEvent.track_events(:browser_pageview) do- expect { Middleware::RequestTracker.log_request(data) }.to change {- BrowserPageviewEvent.count- }.by(1)+ expect { log_browser_pageview(data) }.to change { BrowserPageviewEvent.count }.by(1)endexpect(events).to be_empty+ expect(BrowserPageviewEvent.queued_count).to eq(0)event = BrowserPageviewEvent.lastexpect(event.session_id).to eq(session_id)@@ -973,7 +971,7 @@ RSpec.describe Middleware::RequestTracker do0.2,)- Middleware::RequestTracker.log_request(data)+ log_browser_pageview(data)event = BrowserPageviewEvent.lastexpect(event.referrer).to eq("https://www.example.com/path?utm_source=x")@@ -996,7 +994,7 @@ RSpec.describe Middleware::RequestTracker do0.2,)- Middleware::RequestTracker.log_request(data)+ log_browser_pageview(data)event = BrowserPageviewEvent.lastexpect(event.normalized_referrer).to be_nil@@ -1020,13 +1018,36 @@ RSpec.describe Middleware::RequestTracker doevents =DiscourseEvent.track_events(:browser_pageview) do- expect { Middleware::RequestTracker.log_request(data) }.to change {- BrowserPageviewEvent.count- }.by(1)+ expect { log_browser_pageview(data) }.to change { BrowserPageviewEvent.count }.by(1)endexpect(events).to be_emptyend++ it "queues browser pageviews while PostgreSQL is readonly" do+ session_id = "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx"+ Discourse.enable_readonly_mode(Discourse::PG_READONLY_MODE_KEY)++ data =+ Middleware::RequestTracker.get_data(+ env(+ "HTTP_DISCOURSE_TRACK_VIEW" => "1",+ "HTTP_DISCOURSE_TRACK_VIEW_SESSION_ID" => session_id,+ "HTTP_DISCOURSE_TRACK_VIEW_URL" => "https://discourse.org",+ "action_dispatch.remote_ip" => "1.2.3.4",+ ),+ ["200", { "Content-Type" => "text/html" }],+ 0.2,+ )++ expect { log_browser_pageview(data) }.not_to change { BrowserPageviewEvent.count }+ expect(BrowserPageviewEvent.queued_count).to eq(1)++ Discourse.disable_readonly_mode(Discourse::PG_READONLY_MODE_KEY)++ expect { flush_browser_pageview_events }.to change { BrowserPageviewEvent.count }.by(1)+ expect(BrowserPageviewEvent.queued_count).to eq(0)+ endendendenddiff --git a/spec/models/browser_pageview_event_spec.rb b/spec/models/browser_pageview_event_spec.rbindex 12d5be90d37..a43c0e7f5c7 100644--- a/spec/models/browser_pageview_event_spec.rb+++ b/spec/models/browser_pageview_event_spec.rb@@ -1,6 +1,16 @@# frozen_string_literal: trueRSpec.describe BrowserPageviewEvent do+ before do+ described_class.clear_queued!+ Discourse.clear_readonly!+ end++ after do+ described_class.clear_queued!+ Discourse.clear_readonly!+ end+it "truncates string fields before saving" doevent =described_class.create!(@@ -18,4 +28,118 @@ RSpec.describe BrowserPageviewEvent doexpect(event.session_id.length).to eq(described_class::MAX_SESSION_ID_LENGTH)expect(event.normalized_referrer.length).to eq(described_class::MAX_NORMALIZED_REFERRER_LENGTH)end++ describe ".flush_queued!" do+ let(:occurred_at) { Time.zone.parse("2026-05-27 10:30:00") }++ let(:payload) do+ {+ url: "https://discourse.example/t/topic/1",+ ip_address: "1.2.3.4",+ country_code: "AU",+ asn: 12_345,+ referrer: "https://www.example.com/path?utm_source=x",+ user_agent: "Mozilla/5.0",+ session_id: "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx",+ topic_id: 123,+ occurred_at: occurred_at.iso8601(6),+ }+ end++ def queue_payload(payload)+ described_class.enqueue_for_later(payload)+ end++ it "queues payloads without flushing them synchronously" do+ expect { described_class.enqueue_for_later(payload) }.not_to change { described_class.count }++ expect(described_class.queued_count).to eq(1)+ end++ it "persists queued payloads and removes them from Redis" do+ described_class.enqueue_for_later(payload)++ expect { described_class.flush_queued! }.to change { described_class.count }.by(1)++ event = described_class.last+ expect(event.url).to eq(payload[:url])+ expect(event.country_code).to eq("AU")+ expect(event.asn).to eq(12_345)+ expect(event.normalized_referrer).to eq("example.com/path")+ expect(event.created_at).to eq_time(occurred_at)+ expect(described_class.queued_count).to eq(0)+ end++ it "keeps queued payloads while PostgreSQL is readonly" do+ Discourse.stubs(:pg_readonly_mode?).returns(true)+ described_class.enqueue_for_later(payload)++ expect { described_class.flush_queued! }.not_to change { described_class.count }++ expect(described_class.queued_count).to eq(1)+ end++ it "discards invalid payloads without blocking later entries" do+ invalid_payload = payload.merge(occurred_at: "not-a-date")+ valid_payload = payload.merge(url: "https://discourse.example/t/topic/2")+ queue_payload(invalid_payload)+ queue_payload(valid_payload)++ expect { described_class.flush_queued! }.to change { described_class.count }.by(1)++ expect(described_class.last.url).to eq(valid_payload[:url])+ expect(described_class.queued_count).to eq(0)+ end++ it "removes malformed queued payloads without blocking later entries" do+ Discourse.redis.rpush(described_class::REDIS_QUEUE_KEY, "{")+ queue_payload(payload.merge(url: "https://discourse.example/t/topic/4"))++ expect { described_class.flush_queued! }.to change { described_class.count }.by(1)++ expect(described_class.last.url).to eq("https://discourse.example/t/topic/4")+ expect(described_class.queued_count).to eq(0)+ end+ end++ describe ".enqueue_for_later" do+ let(:payload) do+ {+ url: "https://discourse.example/t/topic/1",+ ip_address: "1.2.3.4",+ user_agent: "Mozilla/5.0",+ session_id: "xxxxxxxxxxxx4xxxyxxxxxxxxxxxxxxx",+ occurred_at: Time.zone.parse("2026-05-27 10:30:00").iso8601(6),+ }+ end++ it "skips payloads missing a required field instead of queueing them" do+ expect { described_class.enqueue_for_later(payload.except(:url)) }.not_to change {+ described_class.queued_count+ }+ end++ it "skips payloads with an unparseable IP address instead of queueing them" do+ expect {+ described_class.enqueue_for_later(payload.merge(ip_address: "1.2.3.4/64"))+ }.not_to change { described_class.queued_count }+ end++ it "drops new events once the queue reaches its maximum size" do+ stub_const(described_class, "REDIS_QUEUE_MAX_SIZE", 1) do+ described_class.enqueue_for_later(payload)+ expect { described_class.enqueue_for_later(payload) }.not_to change {+ described_class.queued_count+ }+ end++ expect(described_class.queued_count).to eq(1)+ end++ it "sets an expiry on the queue so a stranded backlog self-cleans" do+ described_class.enqueue_for_later(payload)++ expect(Discourse.redis.ttl(described_class::REDIS_QUEUE_KEY)).to be > 0+ end+ endend