rails_event_viewer 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d1fae32fbd34187f3531ab552271d62005f6c8877bd814ca08207053d349178
-  data.tar.gz: 05b561609b0ad4d7d7065e61e0a67891a8d9b4f2b970366869097a38a4d17293
+  metadata.gz: c9535859f9ef02bb389bd7b17f4d9c34329c199c4af3cf6e97effeaa5ad27b52
+  data.tar.gz: 404478f207dae7bcfc10152b3832bb6a9200d4ec1e36c9a1a36ce1cd2ac4ff0c
 SHA512:
-  metadata.gz: 38ee32bc44c4fd20adf78b42e8d9110c1328615fe0072bfe00325d9c76fc7eba4ed3f909a98cabf0e6c345b4f8fb64cca6802255c5c7ab3721731bef3bfc91ee
-  data.tar.gz: 0040bd1d2ce832bc80e35cac7248bc6461375f703f3ae299913264b43955d07e2b8a947bb0b9b349128f0aa45d352a5e5cc4b52401554943141e3fe5eec06962
+  metadata.gz: 15c2c7235db0b5e5b4694c5ddffd7f71c543560670011db7984d19e68dd4ba7848fa71934a6755cac6055f2e29414b4f9d3318ee4e0d3b7382c37ba23303cd0f
+  data.tar.gz: a32771c3b8d554d69445b037aa8e8b64a1fb2dd2d7e84169a665c61bd83b632cac2f863ec3d5c65c195f772fd49c0af7af56cdfa0af08712d4381478bb7c614e

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.3.0 (2026-10-02)
+
+Breaking:
+
+- Event type and group pages moved to `/event_type?name=...` and `/group?key=...&value=...`. Old links to those pages no longer work.
+- Custom adapters: `counts_by_name` and `events_over_time` now take a `range:` argument.
+- Unknown options for the Redis and memory adapters raise an `ArgumentError`.
+- `with_tag` and `with_context` with a value of `""` or `false` now match that value, not every event that has the key.
+
+Fixed:
+
+- PostgreSQL: group pages no longer raise.
+- MySQL: the migration runs and search works.
+- Event names and group values with a slash no longer break the Event Types and Groups pages.
+- Tag and context filters return the same events on every database and adapter. A value typed as text also matches numbers and booleans.
+- Filter keys with a hyphen, dot, space or quote work on every database.
+- Events the database rejects no longer hold up the events behind them.
+- Payloads that cannot be serialized, such as invalid UTF-8, are stored as text.
+- A dropped connection during the first table check no longer stops capture until restart.
+- The analytics page respects its date range.
+- The generated Redis config suggests `redis_options`, which the adapter reads.
+- The generated initializer adds to `ignored_events` and keeps the defaults.
+
+Changed:
+
+- Removed two unused analytics endpoints.
+- The engine migration has a new timestamp and targets Rails 8.1. Apps that already installed it need no action.
+
 ## 0.2.1 (2026-10-01)
 
 - Forked workers no longer duplicate the parent's buffered events on exit.

data/README.md

@@ -94,6 +94,17 @@ Set `RAILS_ENV` on every server. Without it, Rails falls back to development and
 
 Set `config.storage_adapter` to `:active_record` (default), `:redis`, `:memory`, or `:null`. Redis needs the `redis` gem and takes options through `config.adapter_options`.
 
+```ruby
+config.storage_adapter = :redis
+config.adapter_options = {
+  redis_options: { url: ENV["REDIS_URL"] },  # passed to Redis.new
+  key_prefix: "rails_event_viewer",
+  max_events: 10_000
+}
+```
+
+Pass `pool:` to use your own `ConnectionPool`, or `pool_size:` and `pool_timeout:` to size the built-in one. The memory adapter takes `max_events:`. An unknown option raises an `ArgumentError`.
+
 Filtered queries on Redis scan every stored event, so keep `max_events` (how many events Redis keeps, set in `adapter_options`) modest. For your own storage, include `RailsEventViewer::Adapter`.
 
 ## Rake tasks
@@ -119,7 +130,16 @@ production:
 ```bash
 bundle install
 bundle exec rake test
-cd test/dummy && bin/rails db:migrate && bin/rails server
+bin/rails db:migrate && bin/rails server
+```
+
+`rake test` prepares the test database first. Run it once before running a single test file.
+
+To test against PostgreSQL or MySQL, set `DATABASE_URL`:
+
+```bash
+DATABASE_URL=postgresql://localhost/rails_event_viewer_test bundle exec rake test
+DATABASE_URL=trilogy://root@127.0.0.1/rails_event_viewer_test bundle exec rake test
 ```
 
 ## License

data/Rakefile

@@ -13,4 +13,6 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = false
 end
 
+task test: "app:db:prepare"
+
 task default: :test

data/app/controllers/rails_event_viewer/analytics_controller.rb

@@ -4,42 +4,17 @@ module RailsEventViewer
 
     def overview
       @date_range = parse_date_range
+      counts = current_adapter.counts_by_name(range: @date_range)
 
-      relation = RailsEventViewer.events
-                   .since(@date_range.begin)
-                   .until(@date_range.end)
-
-      @total_events = relation.count
-      @unique_event_types = current_adapter.distinct_event_names.size
-      @events_by_type = current_adapter.counts_by_name(limit: 20)
-      @events_over_time = current_adapter.events_over_time(since: @date_range.begin, interval: period_for_range)
+      @total_events = counts.values.sum
+      @unique_event_types = counts.size
+      @events_by_type = counts.first(20).to_h
+      @events_over_time = current_adapter.events_over_time(range: @date_range, interval: period_for_range)
 
       @avg_events_per_hour = calculate_avg_events_per_hour
       @peak_period = find_peak_period
     end
 
-    def events_over_time
-      since = params[:since]&.to_i&.seconds&.ago || 24.hours.ago
-      interval = params[:interval]&.to_sym || :hour
-
-      @events_data = current_adapter.events_over_time(since: since, interval: interval)
-
-      respond_to do |format|
-        format.json { render json: @events_data }
-        format.html { render partial: "events_over_time_chart" }
-      end
-    end
-
-    def events_by_type
-      limit = (params[:limit] || 20).to_i.clamp(1, 100)
-      @data = current_adapter.counts_by_name(limit: limit)
-
-      respond_to do |format|
-        format.json { render json: @data }
-        format.html { render partial: "events_by_type_chart" }
-      end
-    end
-
     private
 
     def check_analytics_support

data/app/controllers/rails_event_viewer/application_controller.rb

@@ -42,6 +42,11 @@ module RailsEventViewer
       Time.use_zone(zone, &block)
     end
 
+    def string_param(key)
+      value = params[key]
+      value if value.is_a?(String) && !value.empty?
+    end
+
     def safe_parse_date(date_string, default: nil)
       return default if date_string.blank?
 

data/app/controllers/rails_event_viewer/dashboard_controller.rb

@@ -8,7 +8,7 @@ module RailsEventViewer
 
       if analytics_supported?
         @events_by_type = current_adapter.counts_by_name(limit: 10)
-        @events_over_time = current_adapter.events_over_time(since: 24.hours.ago, interval: :hour)
+        @events_over_time = current_adapter.events_over_time(range: 24.hours.ago.., interval: :hour)
       else
         @events_by_type = {}
         @events_over_time = {}

data/app/controllers/rails_event_viewer/event_types_controller.rb

@@ -5,7 +5,9 @@ module RailsEventViewer
     end
 
     def show
-      @event_type_name = params[:name]
+      @event_type_name = string_param(:name)
+      return redirect_to event_types_path unless @event_type_name
+
       total_events = RailsEventViewer.events.with_name(@event_type_name)
 
       @pagination, @events = paginate(total_events)

data/app/controllers/rails_event_viewer/groups_controller.rb

@@ -17,8 +17,10 @@ module RailsEventViewer
     end
 
     def show
-      @key = params[:key]
-      @value = params[:id]
+      @key = string_param(:key)
+      @value = string_param(:value)
+      return redirect_to groups_path unless @key && @value
+
       @source = source_param
 
       events = if @source == :tags

data/app/views/rails_event_viewer/groups/index.html.erb

@@ -67,7 +67,7 @@
             <% duration = group[:last_event_at] && group[:first_event_at] ? group[:last_event_at] - group[:first_event_at] : nil %>
             <tr class="hover:bg-gray-50">
               <td class="px-6 py-4 whitespace-nowrap">
-                <%= link_to rails_event_viewer.group_path(group[:value], key: @selected_key, source: @source),
+                <%= link_to rails_event_viewer.group_path(value: group[:value], key: @selected_key, source: @source),
                     class: "text-indigo-600 hover:text-indigo-900 font-medium" do %>
                   <code class="text-sm bg-gray-100 px-2 py-1 rounded"><%= group[:value] %></code>
                 <% end %>

data/config/routes.rb

@@ -9,10 +9,11 @@ RailsEventViewer::Engine.routes.draw do
 
   namespace :analytics do
     get :overview
-    get :events_over_time
-    get :events_by_type
   end
 
-  resources :event_types, only: [:index, :show], param: :name, constraints: { name: %r{[^/]+} }
-  resources :groups, only: [:index, :show], constraints: { id: %r{[^/]+} }
+  resources :event_types, only: :index
+  get "event_type", to: "event_types#show", as: :event_type
+
+  resources :groups, only: :index
+  get "group", to: "groups#show", as: :group
 end

data/db/migrate/{20241208000001_create_rails_event_viewer_entries.rb → 20261002121337_create_rails_event_viewer_entries.rb}

@@ -1,13 +1,14 @@
-class CreateRailsEventViewerEntries < ActiveRecord::Migration[8.0]
+class CreateRailsEventViewerEntries < ActiveRecord::Migration[8.1]
   def change
     create_table :rails_event_viewer_entries do |t|
       t.string :name, null: false
 
       # Use jsonb for PostgreSQL (better performance), json for others (SQLite, MySQL)
       json_type = postgresql? ? :jsonb : :json
-      t.column :payload, json_type, default: {}
-      t.column :tags, json_type, default: {}
-      t.column :context, json_type, default: {}
+      json_options = mysql? ? {} : { default: {} }
+      t.column :payload, json_type, **json_options
+      t.column :tags, json_type, **json_options
+      t.column :context, json_type, **json_options
 
       t.string :source_file
       t.integer :source_line
@@ -33,4 +34,8 @@ class CreateRailsEventViewerEntries < ActiveRecord::Migration[8.0]
   def postgresql?
     connection.adapter_name.downcase.include?("postgresql")
   end
+
+  def mysql?
+    connection.adapter_name.match?(/mysql|trilogy/i)
+  end
 end

data/lib/generators/rails_event_viewer/install/templates/create_rails_event_viewer_entries.rb.erb

@@ -4,9 +4,10 @@ class CreateRailsEventViewerEntries < ActiveRecord::Migration<%= migration_versi
       t.string :name, null: false
 
       json_type = postgresql? ? :jsonb : :json
-      t.column :payload, json_type, default: {}
-      t.column :tags, json_type, default: {}
-      t.column :context, json_type, default: {}
+      json_options = mysql? ? {} : { default: {} }
+      t.column :payload, json_type, **json_options
+      t.column :tags, json_type, **json_options
+      t.column :context, json_type, **json_options
 
       t.string :source_file
       t.integer :source_line
@@ -32,4 +33,8 @@ class CreateRailsEventViewerEntries < ActiveRecord::Migration<%= migration_versi
   def postgresql?
     connection.adapter_name.downcase.include?("postgresql")
   end
+
+  def mysql?
+    connection.adapter_name.match?(/mysql|trilogy/i)
+  end
 end

data/lib/generators/rails_event_viewer/install/templates/initializer.rb.erb

@@ -16,9 +16,9 @@ RailsEventViewer.configure do |config|
 <% if storage_adapter == "redis" %>
 
   config.adapter_options = {
-    # redis: Redis.new(url: ENV["REDIS_URL"]),  # Your Redis instance
-    # key_prefix: "rails_event_viewer",          # Key prefix for Redis keys
-    # max_events: 10_000                         # Maximum events to retain
+    # redis_options: { url: ENV["REDIS_URL"] },  # Passed to Redis.new
+    # key_prefix: "rails_event_viewer",           # Key prefix for Redis keys
+    # max_events: 10_000                          # Maximum events to retain
   }
 <% elsif storage_adapter == "active_record" %>
 
@@ -56,14 +56,12 @@ RailsEventViewer.configure do |config|
   # How long to keep events before cleanup (used by retention task)
   # config.retention_period = 7.days
 
-  # Only capture specific events (empty = capture all Rails.event.notify() events)
-  # Note: This only affects events emitted via Rails.event.notify(), NOT internal
-  # Rails instrumentation events (sql.active_record, process_action.action_controller, etc.)
-  # which use ActiveSupport::Notifications and are not captured by this gem.
+  # Only capture specific events (empty = capture every event that is not ignored)
   # config.captured_events = ["user.created", "order.placed"]
 
-  # Ignore specific events (supports strings and regex patterns)
-  # config.ignored_events = ["internal.heartbeat", /^debug\./]
+  # Ignore more events (strings and regex patterns). Use += to keep the defaults,
+  # which skip Rails' own events such as action_controller.* and active_record.*
+  # config.ignored_events += ["internal.heartbeat", /^debug\./]
 
   # Default pagination limit
   # config.per_page = 25

data/lib/rails_event_viewer/adapter.rb

@@ -38,12 +38,12 @@ module RailsEventViewer
       raise NotImplementedError, "#{self.class} must implement #find_event"
     end
 
-    def events_over_time(since:, interval:)
+    def events_over_time(range:, interval:)
       raise NotImplementedError, "#{self.class} must implement #events_over_time" if supports_analytics?
       {}
     end
 
-    def counts_by_name(limit:)
+    def counts_by_name(limit: nil, range: nil)
       raise NotImplementedError, "#{self.class} must implement #counts_by_name" if supports_analytics?
       {}
     end

data/lib/rails_event_viewer/adapters/active_record.rb

@@ -9,7 +9,7 @@ module RailsEventViewer
 
       def table_exists?
         Entry.table_exists?
-      rescue ::ActiveRecord::NoDatabaseError, ::ActiveRecord::StatementInvalid
+      rescue ::ActiveRecord::NoDatabaseError
         false
       end
 
@@ -57,28 +57,13 @@ module RailsEventViewer
         Entry.where("occurred_at < ?", timestamp).in_batches.delete_all
       end
 
-      def events_over_time(since:, interval:)
-        scope = Entry.where("occurred_at >= ?", since)
-
-        case interval
-        when :minute
-          scope.group_by_minute(:occurred_at).count
-        when :hour
-          scope.group_by_hour(:occurred_at).count
-        when :day
-          scope.group_by_day(:occurred_at).count
-        when :week
-          scope.group_by_week(:occurred_at).count
-        else
-          scope.group_by_hour(:occurred_at).count
-        end
+      def events_over_time(range:, interval:)
+        Entry.where(occurred_at: range).group_by_period(interval, :occurred_at).count
       end
 
-      def counts_by_name(limit:)
-        Entry.group(:name)
-             .order(Arel.sql("COUNT(*) DESC"))
-             .limit(limit)
-             .count
+      def counts_by_name(limit: nil, range: nil)
+        scope = range ? Entry.where(occurred_at: range) : Entry
+        scope.group(:name).order(Arel.sql("COUNT(*) DESC")).limit(limit).count
       end
 
       def count_since(since)
@@ -104,12 +89,9 @@ module RailsEventViewer
         json_path = JsonQuery.extract_path(column, key)
 
         Entry
-          .where(JsonQuery.extract_path_not_null(column, key))
+          .where(JsonQuery.extract_path_present(column, key))
           .distinct
           .pluck(Arel.sql(json_path))
-          .compact
-          .map { |v| v.is_a?(String) ? v.gsub(/^"|"$/, "") : v.to_s }
-          .uniq
       end
 
       def group_instances(key, source: :context, limit: 100)
@@ -123,13 +105,13 @@ module RailsEventViewer
             Arel.sql("MIN(occurred_at) as first_event_at"),
             Arel.sql("MAX(occurred_at) as last_event_at")
           )
-          .where(JsonQuery.extract_path_not_null(column, key))
+          .where(JsonQuery.extract_path_present(column, key))
           .group(Arel.sql(json_path))
           .order(Arel.sql("MAX(occurred_at) DESC"))
           .limit(limit)
           .map do |row|
             {
-              value: normalize_group_value(row.group_value),
+              value: row.group_value,
               count: row.event_count,
               first_event_at: parse_timestamp(row.first_event_at),
               last_event_at: parse_timestamp(row.last_event_at)
@@ -142,7 +124,7 @@ module RailsEventViewer
       end
 
       def event_time_span(relation)
-        row = build_scope(relation).pick(
+        row = build_scope(relation).unscope(:order).pick(
           Arel.sql("MIN(occurred_at)"),
           Arel.sql("MAX(occurred_at)")
         )
@@ -161,13 +143,6 @@ module RailsEventViewer
         nil
       end
 
-      def normalize_group_value(value)
-        return nil if value.nil?
-        return value.to_s if value.is_a?(Numeric)
-
-        value.to_s.gsub(/^"|"$/, "")
-      end
-
       def build_scope(relation)
         scope = Entry.order(occurred_at: :desc)
         scope = apply_name_filters(scope, relation)
@@ -215,10 +190,10 @@ module RailsEventViewer
       def apply_search(scope, relation)
         return scope if relation.query.blank?
 
-        sanitized = "%#{Entry.sanitize_sql_like(relation.query.downcase)}%"
+        sanitized = "%#{Entry.sanitize_sql_like(relation.query.downcase, "!")}%"
         text_type = JsonQuery.detect_adapter == :mysql ? "CHAR" : "TEXT"
         scope.where(
-          "LOWER(name) LIKE :q ESCAPE '\\' OR LOWER(CAST(payload AS #{text_type})) LIKE :q ESCAPE '\\'",
+          "LOWER(name) LIKE :q ESCAPE '!' OR LOWER(CAST(payload AS #{text_type})) LIKE :q ESCAPE '!'",
           q: sanitized
         )
       end

data/lib/rails_event_viewer/adapters/concerns/in_memory_filtering.rb

@@ -15,8 +15,8 @@ module RailsEventViewer
 
         def group_instances(key, source: :context, limit: 100)
           in_memory_events
-            .group_by { |e| group_value_for(e, key, source) }
-            .reject { |value, _| value.nil? }
+            .group_by { |e| group_value_for(e, key, source).to_s }
+            .reject { |value, _| value.empty? }
             .map { |value, events| build_group_instance(value, events) }
             .sort_by { |s| -(s[:last_event_at]&.to_f || 0) }
             .take(limit)
@@ -28,8 +28,27 @@ module RailsEventViewer
           [timestamps.min, timestamps.max]
         end
 
+        def events_over_time(range:, interval:)
+          events_in(range)
+            .group_by { |e| TimeUtils.truncate_to_interval(e[:occurred_at], interval) }
+            .transform_values(&:size)
+            .sort
+            .to_h
+        end
+
+        def counts_by_name(limit: nil, range: nil)
+          counts = events_in(range).map { |e| e[:name] }.tally.sort_by { |_, count| -count }
+          (limit ? counts.first(limit) : counts).to_h
+        end
+
         private
 
+        def events_in(range)
+          return in_memory_events unless range
+
+          in_memory_events.select { |e| e[:occurred_at] && range.cover?(e[:occurred_at]) }
+        end
+
         def group_value_for(event, key, source)
           data = event[source]
           data&.dig(key.to_s) || data&.dig(key.to_sym)
@@ -96,7 +115,7 @@ module RailsEventViewer
         def values_match?(actual, expected)
           return false if actual.nil?
 
-          actual == expected || actual.to_s == expected.to_s
+          actual.to_s == expected.to_s
         end
 
         def filter_by_time_range(events, since_time, until_time)

data/lib/rails_event_viewer/adapters/memory.rb

@@ -20,7 +20,7 @@ module RailsEventViewer
         self.class.events
       end
 
-      def initialize(max_events: 1000, **)
+      def initialize(max_events: 1000)
         @max_events = max_events
       end
 
@@ -68,26 +68,6 @@ module RailsEventViewer
         end
       end
 
-      def events_over_time(since:, interval:)
-        snapshot = mutex.synchronize { events.dup }
-        filtered = snapshot.select { |e| e[:occurred_at] && e[:occurred_at] >= since }
-
-        grouped = filtered.group_by do |e|
-          TimeUtils.truncate_to_interval(e[:occurred_at], interval)
-        end
-
-        grouped.transform_values(&:size).sort.to_h
-      end
-
-      def counts_by_name(limit:)
-        mutex.synchronize { events.dup }
-          .group_by { |e| e[:name] }
-          .transform_values(&:size)
-          .sort_by { |_, count| -count }
-          .take(limit)
-          .to_h
-      end
-
       def count_since(since)
         mutex.synchronize { events.count { |e| e[:occurred_at] && e[:occurred_at] >= since } }
       end

data/lib/rails_event_viewer/adapters/null.rb

@@ -39,11 +39,11 @@ module RailsEventViewer
         0
       end
 
-      def events_over_time(since:, interval:)
+      def events_over_time(range:, interval:)
         {}
       end
 
-      def counts_by_name(limit:)
+      def counts_by_name(limit: nil, range: nil)
         {}
       end
 

data/lib/rails_event_viewer/adapters/redis.rb

@@ -20,7 +20,7 @@ module RailsEventViewer
 
       def initialize(redis_options: {}, pool_size: DEFAULT_POOL_SIZE, pool_timeout: DEFAULT_POOL_TIMEOUT,
                      pool: build_pool(pool_size, pool_timeout, redis_options),
-                     key_prefix: DEFAULT_KEY_PREFIX, max_events: DEFAULT_MAX_EVENTS, **)
+                     key_prefix: DEFAULT_KEY_PREFIX, max_events: DEFAULT_MAX_EVENTS)
         @redis = pool
         @key_prefix = "{#{key_prefix}}"
         @max_events = max_events
@@ -105,24 +105,6 @@ module RailsEventViewer
         end
       end
 
-      def events_over_time(since:, interval:)
-        events = fetch_events_since(since)
-
-        events.group_by do |e|
-          TimeUtils.truncate_to_interval(e[:occurred_at], interval)
-        end.transform_values(&:size)
-      end
-
-      def counts_by_name(limit:)
-        serialized_events = @redis.with { |conn| conn.zrevrange(events_key, 0, -1) }
-        serialized_events
-          .map { |json| deserialize_event(json)[:name] }
-          .tally
-          .sort_by { |_, count| -count }
-          .take(limit)
-          .to_h
-      end
-
       def count_since(since)
         score = (since.to_f * 1_000_000).to_i
         @redis.with { |conn| conn.zcount(events_key, score, "+inf") }
@@ -189,12 +171,6 @@ module RailsEventViewer
         data
       end
 
-      def fetch_events_since(since)
-        score = (since.to_f * 1_000_000).to_i
-        serialized_events = @redis.with { |conn| conn.zrangebyscore(events_key, score, "+inf") }
-        serialized_events.map { |json| deserialize_event(json) }
-      end
-
       def fetch_all_events
         serialized_events = @redis.with { |conn| conn.zrevrange(events_key, 0, -1) }
         serialized_events.map { |json| deserialize_event(json) }

data/lib/rails_event_viewer/batch_writer.rb

@@ -47,7 +47,8 @@ module RailsEventViewer
       end
 
       if written.empty?
-        @buffer.revert(events)
+        untried = events.drop(rejected.size)
+        @buffer.revert(untried + rejected)
         return false
       end
 

data/lib/rails_event_viewer/json_query.rb

@@ -1,23 +1,34 @@
 module RailsEventViewer
   module JsonQuery
-    INTEGER_PATTERN = /\A-?\d+\z/ # Matches: "123", "-456", "0"
-    FLOAT_PATTERN = /\A-?\d+\.?\d*\z/ # Matches: "123.45", "-0.5", "123"
     SAFE_KEY_PATTERN = /\A[\w.-]+\z/
 
     module_function
 
     def contains(column, key, value = nil)
+      return exists(column, key) if value.nil?
+
       adapter = detect_adapter
+      return fallback_contains(column, key, value) if adapter == :fallback
+
+      condition = "#{text_at(column, ':path')} = :value"
+      binds = { path: path_for(key), value: value.to_s }
+      return [condition, binds] unless adapter == :postgresql
 
-      case adapter
+      variants = { as_string: value.to_s, as_scalar: parse_scalar(value) }.compact
+      prefilter = variants.keys.map { |name| "#{column} @> :#{name}" }.join(" OR ")
+      ["(#{prefilter}) AND #{condition}", binds.merge(variants.transform_values { |variant| { key.to_s => variant }.to_json })]
+    end
+
+    def exists(column, key)
+      case detect_adapter
       when :postgresql
-        postgresql_contains(column, key, value)
+        ["#{column} ? :key", { key: key.to_s }]
       when :mysql
-        mysql_contains(column, key, value)
+        ["JSON_CONTAINS_PATH(#{column}, 'one', ?)", quoted_path(key)]
       when :sqlite
-        sqlite_contains(column, key, value)
+        ["json_type(#{column}, ?) IS NOT NULL", quoted_path(key)]
       else
-        fallback_contains(column, key, value)
+        fallback_contains(column, key)
       end
     end
 
@@ -36,76 +47,57 @@ module RailsEventViewer
       end
     end
 
-    # PostgreSQL: Uses @> operator for "contains"
-    # Example: tags @> '{"env": "production"}'
-    def postgresql_contains(column, key, value = nil)
-      if value.present?
-        ["#{column} @> ?", { key.to_s => value }.to_json]
-      else
-        ["#{column} ? ?", key.to_s]
-      end
-    end
+    def fallback_contains(column, key, value = nil)
+      escaped_key = key.to_s.gsub(/[%_\\]/) { |m| "\\#{m}" }
 
-    def mysql_contains(column, key, value = nil)
-      if value.present?
-        ["JSON_CONTAINS(#{column}, ?, ?)", value.to_json, "$.#{key}"]
+      if value.nil?
+        ["CAST(#{column} AS TEXT) LIKE ?", "%\"#{escaped_key}\"%"]
       else
-        ["JSON_CONTAINS_PATH(#{column}, 'one', ?)", "$.#{key}"]
+        ["CAST(#{column} AS TEXT) LIKE ?", "%\"#{escaped_key}\":#{value.to_json}%"]
       end
     end
 
-    def sqlite_contains(column, key, value = nil)
-      if value.present?
-        # SQLite stores JSON values with their original types (integers stay integers)
-        # We need to cast the value appropriately for comparison
-        normalized_value = normalize_sqlite_value(value)
-        ["json_extract(#{column}, ?) = ?", "$.#{key}", normalized_value]
-      else
-        ["json_extract(#{column}, ?) IS NOT NULL", "$.#{key}"]
-      end
-    end
+    def extract_path(column, key)
+      raise ArgumentError, "Invalid JSON key: #{key.inspect}" unless key.to_s.match?(SAFE_KEY_PATTERN)
 
-    def normalize_sqlite_value(value)
-      return value unless value.is_a?(String)
+      text_at(column, "'#{path_for(key)}'")
+    end
 
-      if value.match?(INTEGER_PATTERN)
-        value.to_i
-      elsif value.match?(FLOAT_PATTERN)
-        value.to_f
-      else
-        value
-      end
+    def extract_path_present(column, key)
+      path = extract_path(column, key)
+      "#{path} IS NOT NULL AND #{path} <> ''"
     end
 
-    def fallback_contains(column, key, value = nil)
-      if value.present?
-        escaped_key = key.to_s.gsub(/[%_\\]/) { |m| "\\#{m}" }
-        ["CAST(#{column} AS TEXT) LIKE ?", "%\"#{escaped_key}\":#{value.to_json}%"]
+    def text_at(column, path)
+      case detect_adapter
+      when :postgresql
+        "#{column} ->> #{path}"
+      when :mysql
+        "JSON_UNQUOTE(NULLIF(JSON_EXTRACT(#{column}, #{path}), CAST('null' AS JSON))) COLLATE #{mysql_collation}"
       else
-        escaped_key = key.to_s.gsub(/[%_\\]/) { |m| "\\#{m}" }
-        ["CAST(#{column} AS TEXT) LIKE ?", "%\"#{escaped_key}\"%"]
+        "CASE json_type(#{column}, #{path}) WHEN 'true' THEN 'true' WHEN 'false' THEN 'false' " \
+          "ELSE CAST(json_extract(#{column}, #{path}) AS TEXT) END"
       end
     end
 
-    def extract_path(column, key)
-      raise ArgumentError, "Invalid JSON key: #{key.inspect}" unless key.to_s.match?(SAFE_KEY_PATTERN)
+    def mysql_collation
+      connection = ActiveRecord::Base.connection
+      !connection.mariadb? && connection.database_version >= "8.0.17" ? "utf8mb4_0900_bin" : "utf8mb4_bin"
+    end
 
-      adapter = detect_adapter
+    def path_for(key)
+      detect_adapter == :postgresql ? key.to_s : quoted_path(key)
+    end
 
-      case adapter
-      when :postgresql
-        "#{column} ->> '#{key}'"
-      when :mysql
-        "JSON_UNQUOTE(JSON_EXTRACT(#{column}, '$.#{key}'))"
-      when :sqlite
-        "json_extract(#{column}, '$.#{key}')"
-      else
-        "json_extract(#{column}, '$.#{key}')"
-      end
+    def quoted_path(key)
+      %($."#{key.to_s.gsub(/["\\]/) { |m| "\\#{m}" }}")
     end
 
-    def extract_path_not_null(column, key)
-      "#{extract_path(column, key)} IS NOT NULL"
+    def parse_scalar(value)
+      parsed = JSON.parse(value.to_s)
+      parsed if parsed.is_a?(Numeric) || parsed == true || parsed == false
+    rescue JSON::ParserError
+      nil
     end
   end
 end

data/lib/rails_event_viewer/subscriber.rb

@@ -93,8 +93,7 @@ module RailsEventViewer
     end
 
     def snapshot(value)
-      json = value.as_json
-      json.is_a?(Hash) ? json.deep_symbolize_keys : json
+      JSON.parse(JSON.generate(value.as_json), symbolize_names: true)
     rescue SystemStackError, StandardError
       { value: value.inspect }
     end

data/lib/rails_event_viewer/time_utils.rb

@@ -8,16 +8,9 @@ module RailsEventViewer
       return nil unless time
 
       case interval
-      when :minute
-        time.beginning_of_minute
-      when :hour
-        time.beginning_of_hour
-      when :day
-        time.beginning_of_day
-      when :week
-        time.beginning_of_week
-      else
-        time.beginning_of_hour
+      when :hour then time.beginning_of_hour
+      when :day then time.beginning_of_day
+      else raise ArgumentError, "Unknown interval: #{interval.inspect}"
       end
     end
   end

data/lib/rails_event_viewer/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_event_viewer
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Keshav Biswa
@@ -95,7 +95,7 @@ files:
 - app/views/rails_event_viewer/shared/_pagination.html.erb
 - app/views/rails_event_viewer/shared/_stat_card.html.erb
 - config/routes.rb
-- db/migrate/20241208000001_create_rails_event_viewer_entries.rb
+- db/migrate/20261002121337_create_rails_event_viewer_entries.rb
 - lib/generators/rails_event_viewer/install/USAGE
 - lib/generators/rails_event_viewer/install/install_generator.rb
 - lib/generators/rails_event_viewer/install/templates/create_rails_event_viewer_entries.rb.erb