rails_event_viewer 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26f6b1798d95bf71759a16da1fd092f8d8296a4118378a8c5ce84e12848efe28
-  data.tar.gz: b290b0d5803b71aa2f8fda06ee160870672a4073c175c2bb6a0e0856f19b2dbc
+  metadata.gz: 5d1fae32fbd34187f3531ab552271d62005f6c8877bd814ca08207053d349178
+  data.tar.gz: 05b561609b0ad4d7d7065e61e0a67891a8d9b4f2b970366869097a38a4d17293
 SHA512:
-  metadata.gz: ef7fc01c18016ff1f9d48de98fcc1f42b248ac1fea588806c6dc3a409b12f75291e4165ee59ff45220b93a024f6b816d7cb2dba4395c2b5c441dd6f323a8a17a
-  data.tar.gz: 896dd1e41a71c0c0bd25dbdd0a376ffd7c5c0c68b8d7d6cf445521127560d95ba0d351e1d9f9f4c6c5d73ed00ae6472dbd9096ceddf2d79cd8b1dbf4e3edb37f
+  metadata.gz: 38ee32bc44c4fd20adf78b42e8d9110c1328615fe0072bfe00325d9c76fc7eba4ed3f909a98cabf0e6c345b4f8fb64cca6802255c5c7ab3721731bef3bfc91ee
+  data.tar.gz: 0040bd1d2ce832bc80e35cac7248bc6461375f703f3ae299913264b43955d07e2b8a947bb0b9b349128f0aa45d352a5e5cc4b52401554943141e3fe5eec06962

data/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.2.1 (2026-10-01)
+
+- Forked workers no longer duplicate the parent's buffered events on exit.
+- Payload, tags and context are snapshotted at emit time as JSON values (`Time` becomes a string).
+- Unserializable payloads are stored via `inspect` instead of raising.
+- The flusher writes inside the Rails executor.
+- Shutdown has a deadline and logs buffered and dropped events.
+
 ## 0.2.0 (2026-10-01)
 
 - Pluggable buffers: `config.buffer` accepts any object implementing `RailsEventViewer::Buffer` (`push`, `drain`, `commit`, `revert`, `dead`, `size`, `after_fork`). `push` returns the new size. The in-memory buffer remains the default.

data/README.md

@@ -63,7 +63,7 @@ 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.
+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. On a normal shutdown, buffered events are written for up to 5 seconds. Anything left is logged and lost. If the process is killed, the whole buffer is lost.
 
 Internal Rails events such as `active_record.*` and `action_controller.*` are ignored by default. Remove a pattern from `ignored_events` to capture it.
 

data/lib/rails_event_viewer/batch_writer.rb

@@ -17,7 +17,7 @@ module RailsEventViewer
       @strikes = Hash.new(0)
     end
 
-    def write(events)
+    def write(events, split: true)
       RailsEventViewer.adapter.write_events(events)
       @buffer.commit(events)
       forget(events)
@@ -26,7 +26,7 @@ module RailsEventViewer
     rescue => e
       log_error("[RailsEventViewer] Failed to write #{events.size} events: #{e.message}")
       @failed_attempts += 1
-      return write_individually(events) if @failed_attempts >= MAX_ATTEMPTS
+      return write_individually(events) if split && @failed_attempts >= MAX_ATTEMPTS
 
       @buffer.revert(events)
       false

data/lib/rails_event_viewer/flusher.rb

@@ -13,6 +13,7 @@ module RailsEventViewer
       @thread = nil
       @shutdown_requested = false
       @dropped_count = 0
+      @writing = 0
       @pid = Process.pid
     end
 
@@ -28,23 +29,34 @@ module RailsEventViewer
     end
 
     def flush!
-      events = @buffer.drain([@buffer.size, max_buffer_size].min)
-      return true if events.empty?
-
-      written = @writer.write(events)
-      report_dropped_events if written
-      written
+      handle_fork_if_needed
+      return true if @buffer.size.zero?
+
+      Rails.application.executor.wrap(source: "application.rails_event_viewer") do
+        events = @buffer.drain([@buffer.size, max_buffer_size].min)
+        next true if events.empty?
+
+        @writing = events.size
+        written = @writer.write(events, split: !shutdown_requested?)
+        report_dropped_events if written
+        written
+      ensure
+        @writing = 0
+      end
     rescue => e
       log_error("[RailsEventViewer] Failed to flush: #{e.message}")
       false
     end
 
     def stop!
+      handle_fork_if_needed
+      deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + shutdown_timeout
       @mutex.synchronize { @shutdown_requested = true }
 
       if @thread&.alive?
         @flush_requests << true
-        @thread.join(SHUTDOWN_TIMEOUT_SECONDS)
+        @thread.join(shutdown_timeout)
+        effective_logger&.warn("[RailsEventViewer] Flusher thread still busy after #{shutdown_timeout}s writing #{@writing} events") if @thread.alive?
       end
 
       @mutex.synchronize { @thread = nil }
@@ -52,10 +64,15 @@ module RailsEventViewer
       loop do
         remaining = @buffer.size
         break if remaining.zero?
+        break if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
 
         flush!
-        break if @buffer.size >= remaining
+        break if @buffer.size >= remaining # no progress, stop retrying
       end
+
+      report_dropped_events
+      leftover = @buffer.size
+      effective_logger&.warn("[RailsEventViewer] #{leftover} events still buffered at shutdown") if leftover.positive?
     end
 
     def running?
@@ -82,6 +99,10 @@ module RailsEventViewer
       end
     end
 
+    def shutdown_timeout
+      SHUTDOWN_TIMEOUT_SECONDS
+    end
+
     def max_buffer_size
       RailsEventViewer.buffer_size * MAX_BUFFER_MULTIPLIER
     end
@@ -98,7 +119,11 @@ module RailsEventViewer
     end
 
     def report_dropped_events
-      dropped = @mutex.synchronize { @dropped_count.tap { @dropped_count = 0 } }
+      dropped = @mutex.synchronize do
+        count = @dropped_count
+        @dropped_count = 0
+        count
+      end
       return if dropped.zero?
 
       effective_logger&.warn("[RailsEventViewer] Dropped #{dropped} events because the buffer was full")

data/lib/rails_event_viewer/subscriber.rb

@@ -82,9 +82,9 @@ module RailsEventViewer
 
       {
         name: event[:name],
-        payload: serialize_payload(event[:payload]),
-        tags: event[:tags] || {},
-        context: event[:context] || {},
+        payload: snapshot(serialize_payload(event[:payload])),
+        tags: snapshot(event[:tags] || {}),
+        context: snapshot(event[:context] || {}),
         source_file: event.dig(:source_location, :filepath),
         source_line: event.dig(:source_location, :lineno),
         source_label: event.dig(:source_location, :label),
@@ -92,6 +92,13 @@ module RailsEventViewer
       }
     end
 
+    def snapshot(value)
+      json = value.as_json
+      json.is_a?(Hash) ? json.deep_symbolize_keys : json
+    rescue SystemStackError, StandardError
+      { value: value.inspect }
+    end
+
     def serialize_payload(payload)
       case payload
       when Hash

data/lib/rails_event_viewer/version.rb

@@ -1,3 +1,3 @@
 module RailsEventViewer
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

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