rails_event_viewer 0.2.1 → 0.3.1

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

@@ -49,7 +49,7 @@
       </div>
     </div>
   <% elsif @groups.any? %>
-    <div class="bg-white shadow rounded-lg overflow-hidden">
+    <div class="bg-white shadow rounded-lg overflow-x-auto">
       <table class="min-w-full divide-y divide-gray-200">
         <thead class="bg-gray-50">
           <tr>
@@ -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/app/views/rails_event_viewer/groups/show.html.erb

@@ -19,15 +19,11 @@
   </div>
 
   <!-- Stats -->
-  <div class="grid grid-cols-1 gap-5 sm:grid-cols-4">
+  <div class="grid grid-cols-1 gap-5 sm:grid-cols-3">
     <%= render "rails_event_viewer/shared/stat_card",
         title: "Total Events",
         value: number_with_delimiter(@total_count),
         icon: "database" %>
-    <%= render "rails_event_viewer/shared/stat_card",
-        title: "Event Types",
-        value: @event_names.size,
-        icon: "tag" %>
     <%= render "rails_event_viewer/shared/stat_card",
         title: "Duration",
         value: @duration ? format_duration(@duration) : "-",

data/app/views/rails_event_viewer/shared/_navigation.html.erb

@@ -1,13 +1,13 @@
 <nav class="bg-indigo-600">
   <div class="mx-auto max-w-7xl px-4 sm:px-6 lg:px-8">
-    <div class="flex h-16 items-center justify-between">
+    <div class="flex min-h-16 flex-wrap items-center justify-between gap-y-2 py-2">
       <div class="flex items-center">
         <div class="flex-shrink-0">
           <%= link_to rails_event_viewer.root_path, class: "text-white text-xl font-bold" do %>
             Event Viewer
           <% end %>
         </div>
-        <div class="ml-10 flex items-baseline space-x-4">
+        <div class="ml-10 flex flex-wrap items-baseline space-x-4">
           <%= link_to "Dashboard", rails_event_viewer.root_path,
               class: nav_link_class("dashboard") %>
           <%= link_to "Events", rails_event_viewer.events_path,
@@ -16,14 +16,16 @@
               class: nav_link_class("event_types") %>
           <%= link_to "Groups", rails_event_viewer.groups_path,
               class: nav_link_class("groups") %>
-          <%= link_to "Analytics", rails_event_viewer.analytics_overview_path,
-              class: nav_link_class("analytics") %>
+          <% if analytics_supported? %>
+            <%= link_to "Analytics", rails_event_viewer.analytics_overview_path,
+                class: nav_link_class("analytics") %>
+          <% end %>
         </div>
       </div>
 
       <div class="flex items-center space-x-4">
         <!-- Search -->
-        <%= form_with url: rails_event_viewer.search_events_path, method: :get, class: "relative", data: { turbo_frame: "_top" } do |f| %>
+        <%= form_with url: rails_event_viewer.events_path, method: :get, class: "relative" do |f| %>
           <div class="relative">
             <div class="pointer-events-none absolute inset-y-0 left-0 flex items-center pl-3">
               <svg class="h-4 w-4 text-indigo-200" fill="none" viewBox="0 0 24 24" stroke="currentColor">

data/config/routes.rb

@@ -1,18 +1,15 @@
 RailsEventViewer::Engine.routes.draw do
   root to: "dashboard#index"
 
-  resources :events, only: [:index, :show] do
-    collection do
-      get :search
-    end
-  end
+  resources :events, only: [:index, :show]
 
   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,17 @@ module RailsEventViewer
         Entry.where("occurred_at < ?", timestamp).in_batches.delete_all
       end
 
-      def events_over_time(since:, interval:)
-        scope = Entry.where("occurred_at >= ?", since)
+      def clear!
+        Entry.in_batches.delete_all
+      end
 
-        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 +93,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 +109,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 +128,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 +147,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 +194,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,34 @@ 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
+
+        def event_type_statistics
+          statistics = in_memory_events.group_by { |e| e[:name] }.map do |name, events|
+            { name: name, count: events.size, last_event_at: events.filter_map { |e| e[:occurred_at] }.max }
+          end
+          statistics.sort_by { |statistic| -statistic[:count] }
+        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 +122,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
@@ -99,30 +99,12 @@ module RailsEventViewer
       def delete_before(timestamp)
         score = (timestamp.to_f * 1_000_000).to_i
         @redis.with do |conn|
-          deleted = conn.zremrangebyscore(events_key, "-inf", score)
+          deleted = conn.zremrangebyscore(events_key, "-inf", "(#{score}")
           prune_names(conn)
           deleted
         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") }
@@ -173,8 +155,8 @@ module RailsEventViewer
 
       def serialize_event(event, timestamp_usec = nil)
         timestamp_usec ||= (event[:occurred_at].to_f * 1_000_000).to_i
-        event_with_id = event.merge(id: "#{timestamp_usec}-#{SecureRandom.hex(8)}")
-        JSON.generate(event_with_id)
+        stored = event.merge(id: "#{timestamp_usec}-#{SecureRandom.hex(8)}", occurred_at: event[:occurred_at]&.iso8601(6))
+        JSON.generate(stored)
       end
 
       def deserialize_event(json)
@@ -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/events_relation.rb

@@ -18,7 +18,7 @@ module RailsEventViewer
     end
 
     def with_name(*event_names)
-      event_names = event_names.flatten.compact
+      event_names = event_names.flatten.compact.map(&:to_s)
       return self if event_names.empty?
 
       clone_with { |rel| rel.names.concat(event_names) }

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