rails_event_viewer 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ef30fa1ce21c1dc5c6eaa4634707801f2d32b67ab561231865cc67c0eb2c557f
-  data.tar.gz: 9a423c1745dfb3a088137fbe4c912c069a1e65ca68afc0e4d1dac2961819baac
+  metadata.gz: df70eeee67ca7c67116c852f98659be2d9ee3803a1bd4b949d3190f0aed1d40b
+  data.tar.gz: 0a83f0ce0b0504c7ba9823a1e2c3eaa1e9a4f79297aae5ff35e8f742c01b51ea
 SHA512:
-  metadata.gz: 3b25d996bb14c0bada11737d07a98f93fbd10b8f4781ea3163b79185e31a2b6fe30a99b74e69f63e1d6e768a1fa137124bab9f3a47da07f5940466de1933e2ff
-  data.tar.gz: 828ddff25e0930d10bc34c75ee58e789f361f6dc14c3bf24c56b463e8b1327b454cf15ce7536f7d32969716f4c6db82bd9640c3bfcada4a8c9aed072132bc158
+  metadata.gz: 23eaca12170699b79b5fd635204e24a25bfc6a8eb8bbef0605aeaea40fab2701dda65ca4101fb9d64fea1a5c57fc77a9f94d6362a90f91fea587b196b5d38667
+  data.tar.gz: 8d981f6fe1a2673e91453ddf400be91537bd8b3686217c471e783939f9814ecc0b6240c368689c45219011e6d19ccdfed2e98ea19b61f7dcfcd2e0b5095267a9

data/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.1.3 (2026-10-01)
+
+- The flusher thread starts on the first buffered event, not at boot, so consoles and rake tasks no longer run an idle thread.
+- Flusher start/stop messages log at debug level.
+- Events emitted after shutdown are written immediately instead of lost.
+- Web requests never write to storage. A full buffer wakes the flusher thread instead.
+- The buffer is capped at 10 times `buffer_size`. Overflow drops the oldest events and logs a warning.
+- Removed the unused ActionCable broadcast.
+
 ## 0.1.2 (2026-09-30)
 
 - Removed the `pagy` dependency. Pagination is handled by a small built-in class, so host apps on any Pagy version, or none, can install the gem.

data/README.md

@@ -61,6 +61,8 @@ RailsEventViewer.configure do |config|
 end
 ```
 
+With `async`, events are written by a background thread, never by your web requests. The buffer holds at most 10 times `buffer_size` events. If storage can't keep up, the oldest are dropped and a warning is logged. Events still in the buffer are written on a normal shutdown but lost if the process is killed.
+
 Internal Rails events such as `active_record.*` and `action_controller.*` are ignored by default. Remove a pattern from `ignored_events` to capture it.
 
 ## Authentication

data/lib/rails_event_viewer/subscriber.rb

@@ -4,16 +4,16 @@ module RailsEventViewer
   class Subscriber
     NANOSECONDS_PER_SECOND = 1_000_000_000.0
     SHUTDOWN_TIMEOUT_SECONDS = 5
-    ACTION_CABLE_CHANNEL = "rails_event_viewer:events"
+    MAX_BUFFER_MULTIPLIER = 10
 
     def initialize
       @buffer = Queue.new
+      @flush_requests = Queue.new
       @mutex = Mutex.new
       @flusher_thread = nil
       @shutdown_requested = false
+      @dropped_count = 0
       @pid = Process.pid
-
-      ensure_flusher_thread!
     end
 
     def emit(event)
@@ -41,7 +41,7 @@ module RailsEventViewer
       return if events_to_write.empty?
 
       write_immediately(events_to_write)
-      broadcast_events(events_to_write)
+      report_dropped_events
     end
 
     def stop!
@@ -50,7 +50,7 @@ module RailsEventViewer
       end
 
       if @flusher_thread&.alive?
-        @flusher_thread.wakeup rescue nil
+        @flush_requests << true
         @flusher_thread.join(SHUTDOWN_TIMEOUT_SECONDS)
       end
 
@@ -58,7 +58,7 @@ module RailsEventViewer
         @flusher_thread = nil
       end
 
-      flush!
+      flush! until @buffer.empty?
     end
 
     def running?
@@ -77,25 +77,56 @@ module RailsEventViewer
         if @pid != Process.pid
           @pid = Process.pid
           @buffer = Queue.new
+          @flush_requests = Queue.new
           @flusher_thread = nil
           @shutdown_requested = false
+          @dropped_count = 0
         end
       end
-      ensure_flusher_thread!
     end
 
     def drain_buffer
       events = []
-      loop { events << @buffer.pop(true) }
+      [@buffer.size, max_buffer_size].min.times { events << @buffer.pop(true) }
+      events
     rescue ThreadError
       events
     end
 
     def buffer_event(entry)
       @buffer << entry
+      return flush! if shutdown_requested?
+
       ensure_flusher_thread!
+      drop_oldest_events if @buffer.size > max_buffer_size
+      request_flush if @buffer.size >= RailsEventViewer.buffer_size
+    end
 
-      flush! if @buffer.size >= RailsEventViewer.buffer_size
+    def max_buffer_size
+      RailsEventViewer.buffer_size * MAX_BUFFER_MULTIPLIER
+    end
+
+    def drop_oldest_events
+      dropped = 0
+      while @buffer.size > max_buffer_size
+        @buffer.pop(true)
+        dropped += 1
+      end
+    rescue ThreadError
+      nil
+    ensure
+      @mutex.synchronize { @dropped_count += dropped } if dropped.positive?
+    end
+
+    def report_dropped_events
+      dropped = @mutex.synchronize { @dropped_count.tap { @dropped_count = 0 } }
+      return if dropped.zero?
+
+      effective_logger&.warn("[RailsEventViewer] Dropped #{dropped} events because the buffer was full")
+    end
+
+    def request_flush
+      @flush_requests << true if @flush_requests.empty?
     end
 
     def ensure_flusher_thread!
@@ -110,18 +141,21 @@ module RailsEventViewer
     end
 
     def run_flusher_loop
-      log_info("[RailsEventViewer] Flusher thread started (PID: #{Process.pid})")
+      effective_logger&.debug("[RailsEventViewer] Flusher thread started (PID: #{Process.pid})")
 
       until shutdown_requested?
         begin
-          sleep(RailsEventViewer.flush_interval)
-          flush! unless @buffer.empty?
+          @flush_requests.pop(timeout: RailsEventViewer.flush_interval)
+          loop do
+            flush!
+            break if @buffer.size < RailsEventViewer.buffer_size || shutdown_requested?
+          end
         rescue => e
           log_error("[RailsEventViewer] Flusher error: #{e.message}")
         end
       end
 
-      log_info("[RailsEventViewer] Flusher thread stopped (PID: #{Process.pid})")
+      effective_logger&.debug("[RailsEventViewer] Flusher thread stopped (PID: #{Process.pid})")
     end
 
     def shutdown_requested?
@@ -136,22 +170,6 @@ module RailsEventViewer
       log_error("[RailsEventViewer] Failed to write #{events.size} events: #{e.message}")
     end
 
-    def broadcast_events(events)
-      return unless defined?(ActionCable)
-      return unless events.any?
-
-      ActionCable.server.broadcast(
-        ACTION_CABLE_CHANNEL,
-        {
-          action: "new_events",
-          count: events.size,
-          events: events.map { |e| { name: e[:name], occurred_at: e[:occurred_at]&.iso8601 } }
-        }
-      )
-    rescue => e
-      log_error("[RailsEventViewer] Broadcast error: #{e.message}")
-    end
-
     def should_capture?(event)
       return false unless event.is_a?(Hash)
       return false if event[:name].blank?
@@ -234,10 +252,6 @@ module RailsEventViewer
       log_error("[RailsEventViewer] Failed to capture event '#{event[:name]}': #{error.message}")
     end
 
-    def log_info(message)
-      effective_logger&.info(message)
-    end
-
     def log_error(message)
       logger = effective_logger
 

data/lib/rails_event_viewer/version.rb

@@ -1,3 +1,3 @@
 module RailsEventViewer
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_event_viewer
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Keshav Biswa