rails_event_viewer 0.1.0

data/lib/rails_event_viewer/adapters/null.rb

@@ -0,0 +1,63 @@
+module RailsEventViewer
+  module Adapters
+    class Null
+      include Adapter
+
+      def supports_persistence?
+        false
+      end
+
+      def supports_analytics?
+        false
+      end
+
+      def supports_retention?
+        false
+      end
+
+      def write_events(events)
+        nil
+      end
+
+      def fetch_events(relation)
+        []
+      end
+
+      def count_events(relation)
+        0
+      end
+
+      def distinct_event_names
+        []
+      end
+
+      def find_event(id)
+        nil
+      end
+
+      def delete_before(timestamp)
+        0
+      end
+
+      def events_over_time(since:, interval:)
+        {}
+      end
+
+      def counts_by_name(limit:)
+        {}
+      end
+
+      def count_since(since)
+        0
+      end
+
+      def distinct_group_values(key, source: :context)
+        []
+      end
+
+      def group_instances(key, source: :context, limit: 100)
+        []
+      end
+    end
+  end
+end

data/lib/rails_event_viewer/adapters/redis.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require_relative "concerns/in_memory_filtering"
+
+module RailsEventViewer
+  module Adapters
+    class Redis
+      include Adapter
+      include Concerns::InMemoryFiltering
+
+      DEFAULT_KEY_PREFIX = "rails_event_viewer"
+      DEFAULT_MAX_EVENTS = 10_000
+      DEFAULT_POOL_SIZE = 5
+      DEFAULT_POOL_TIMEOUT = 5
+      NAME_BATCH_TTL_SECONDS = 60
+
+      # Matches event IDs in format: microsecond_timestamp-hex
+      # Example: "1702089600123456-a1b2c3d4e5f6g7h8"
+      EVENT_ID_PATTERN = /^(\d+)-([a-f0-9]+)$/i
+
+      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, **)
+        @redis = pool
+        @key_prefix = "{#{key_prefix}}"
+        @max_events = max_events
+      end
+
+      def supports_analytics?
+        true
+      end
+
+      def write_events(events)
+        return if events.empty?
+
+        newest_by_name = Hash.new(0)
+        batch_key = "#{@key_prefix}:name_batch:#{SecureRandom.hex(8)}"
+
+        @redis.with do |redis|
+          results = redis.pipelined do |pipe|
+            events.each do |event|
+              timestamp_usec = (event[:occurred_at].to_f * 1_000_000).to_i
+              pipe.zadd(events_key, timestamp_usec, serialize_event(event, timestamp_usec))
+              name = event[:name].to_s
+              newest_by_name[name] = timestamp_usec if timestamp_usec > newest_by_name[name]
+            end
+            pipe.zadd(batch_key, newest_by_name.map { |name, score| [score, name] })
+            pipe.expire(batch_key, NAME_BATCH_TTL_SECONDS)
+            pipe.zunionstore(names_key, [names_key, batch_key], aggregate: "max")
+            pipe.del(batch_key)
+            pipe.zremrangebyrank(events_key, 0, -@max_events - 1)
+          end
+
+          prune_names(redis) if results.last.to_i.positive?
+        end
+      end
+
+      def fetch_events(relation)
+        if relation.filtered?
+          return fetch_all_filtered(relation).drop(relation.offset_value).take(relation.limit_value)
+        end
+
+        start_idx = relation.offset_value
+        end_idx = start_idx + relation.limit_value - 1
+
+        @redis.with { |conn| conn.zrevrange(events_key, start_idx, end_idx) }.map { |json| deserialize_event(json) }
+      end
+
+      def count_events(relation)
+        if relation.filtered?
+          fetch_all_filtered(relation).size
+        else
+          @redis.with { |conn| conn.zcard(events_key) }
+        end
+      end
+
+      def distinct_event_names
+        @redis.with { |conn| conn.zrange(names_key, 0, -1).sort }
+      end
+
+      def find_event(id)
+        id_str = id.to_s
+        match = id_str.match(EVENT_ID_PATTERN)
+        return nil unless match
+
+        timestamp_usec = match[1].to_i
+
+        serialized_events = @redis.with { |conn| conn.zrangebyscore(events_key, timestamp_usec, timestamp_usec) }
+        return nil if serialized_events.empty?
+
+        serialized_events.each do |json|
+          event = deserialize_event(json)
+          return event if event[:id] == id_str
+        end
+
+        nil
+      end
+
+      def delete_before(timestamp)
+        score = (timestamp.to_f * 1_000_000).to_i
+        @redis.with do |conn|
+          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") }
+      end
+
+      def clear!
+        @redis.with { |conn| conn.del(events_key, names_key) }
+      end
+
+      private
+
+      def build_pool(size, timeout, redis_options)
+        require "connection_pool"
+        ConnectionPool.new(size: size, timeout: timeout) { build_redis(redis_options) }
+      rescue LoadError
+        raise ArgumentError, "connection_pool gem not loaded. Add `gem 'connection_pool'` to your Gemfile."
+      end
+
+      def build_redis(options)
+        if defined?(::Redis)
+          ::Redis.new(**options)
+        else
+          raise ArgumentError, "Redis gem not loaded. Add `gem 'redis'` to your Gemfile."
+        end
+      end
+
+      def events_key
+        "#{@key_prefix}:events"
+      end
+
+      def names_key
+        "#{@key_prefix}:name_index"
+      end
+
+      def prune_names(conn)
+        conn.watch(events_key) do
+          oldest = conn.zrange(events_key, 0, 0, with_scores: true).first
+
+          conn.multi do |tx|
+            if oldest
+              tx.zremrangebyscore(names_key, "-inf", "(#{oldest.last.to_i}")
+            else
+              tx.del(names_key)
+            end
+          end
+        end
+      end
+
+      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)
+      end
+
+      def deserialize_event(json)
+        data = JSON.parse(json, symbolize_names: true)
+
+        if data[:occurred_at].is_a?(String)
+          data[:occurred_at] = Time.parse(data[:occurred_at])
+        elsif data[:occurred_at].is_a?(Numeric)
+          data[:occurred_at] = Time.at(data[:occurred_at])
+        end
+
+        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) }
+      end
+
+      def fetch_all_filtered(relation)
+        events = fetch_all_events
+        filter_events(events, relation)
+      end
+
+      def in_memory_events
+        fetch_all_events
+      end
+    end
+  end
+end

data/lib/rails_event_viewer/engine.rb

@@ -0,0 +1,24 @@
+module RailsEventViewer
+  class Engine < ::Rails::Engine
+    isolate_namespace RailsEventViewer
+
+    initializer "rails_event_viewer.middleware" do |app|
+      if app.config.api_only
+        config.middleware.use ActionDispatch::Flash
+        config.middleware.use Rack::MethodOverride
+      end
+    end
+
+    initializer "rails_event_viewer.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.paths << root.join("app/assets/stylesheets")
+        app.config.assets.precompile += %w[rails_event_viewer/application.css]
+      end
+    end
+
+    config.after_initialize do
+      RailsEventViewer.subscribe!
+      at_exit { RailsEventViewer.shutdown! }
+    end
+  end
+end

data/lib/rails_event_viewer/events_relation.rb

@@ -0,0 +1,130 @@
+module RailsEventViewer
+  class EventsRelation
+    include Enumerable
+
+    attr_reader :names, :tags, :contexts, :query, :since_time, :until_time
+    attr_reader :limit_value, :offset_value
+
+    def initialize(adapter: RailsEventViewer.adapter)
+      @adapter = adapter
+      @names = []
+      @tags = {}
+      @contexts = {}
+      @query = nil
+      @since_time = nil
+      @until_time = nil
+      @limit_value = RailsEventViewer.per_page
+      @offset_value = 0
+    end
+
+    def with_name(*event_names)
+      event_names = event_names.flatten.compact
+      return self if event_names.empty?
+
+      clone_with { |rel| rel.names.concat(event_names) }
+    end
+
+    def with_tag(key, value = nil)
+      return self if key.blank?
+
+      clone_with { |rel| rel.tags[key.to_s] = value }
+    end
+
+    def with_context(key, value = nil)
+      return self if key.blank?
+
+      clone_with { |rel| rel.contexts[key.to_s] = value }
+    end
+
+    def search(term)
+      return self if term.blank?
+
+      clone_with { |rel| rel.query = term.to_s }
+    end
+
+    def since(time)
+      return self if time.nil?
+
+      clone_with { |rel| rel.since_time = time }
+    end
+
+    def until(time)
+      return self if time.nil?
+
+      clone_with { |rel| rel.until_time = time }
+    end
+
+    def limit(value)
+      clone_with { |rel| rel.limit_value = value.to_i }
+    end
+
+    def offset(value)
+      clone_with { |rel| rel.offset_value = value.to_i }
+    end
+
+    def each(&block)
+      return to_enum(:each) unless block_given?
+
+      @adapter.fetch_events(self).each(&block)
+    end
+
+    def count
+      @adapter.count_events(self)
+    end
+
+    alias_method :size, :count
+    alias_method :length, :count
+
+    def to_a
+      @adapter.fetch_events(self).to_a
+    end
+
+    def any?
+      count > 0
+    end
+
+    def empty?
+      count == 0
+    end
+
+    alias_method :none?, :empty?
+
+    def first
+      limit(1).to_a.first
+    end
+
+    def last
+      return @adapter.fetch_last(self) if @adapter.respond_to?(:fetch_last)
+
+      n = count
+      offset(n - 1).first if n.positive?
+    end
+
+    def filtered?
+      names.any? || tags.any? || contexts.any? || query.present? || since_time.present? || until_time.present?
+    end
+
+    def inspect
+      "#<#{self.class.name} names=#{names.inspect} tags=#{tags.inspect} " \
+        "contexts=#{contexts.inspect} query=#{query.inspect} " \
+        "since=#{since_time.inspect} until=#{until_time.inspect} " \
+        "limit=#{limit_value} offset=#{offset_value}>"
+    end
+
+    private
+
+    def clone_with
+      dup.tap do |rel|
+        rel.instance_variable_set(:@names, @names.dup)
+        rel.instance_variable_set(:@tags, @tags.dup)
+        rel.instance_variable_set(:@contexts, @contexts.dup)
+        yield rel if block_given?
+      end
+    end
+
+    protected
+
+    attr_writer :names, :tags, :contexts, :query, :since_time, :until_time
+    attr_writer :limit_value, :offset_value
+  end
+end

data/lib/rails_event_viewer/json_query.rb

@@ -0,0 +1,111 @@
+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)
+      adapter = detect_adapter
+
+      case adapter
+      when :postgresql
+        postgresql_contains(column, key, value)
+      when :mysql
+        mysql_contains(column, key, value)
+      when :sqlite
+        sqlite_contains(column, key, value)
+      else
+        fallback_contains(column, key, value)
+      end
+    end
+
+    def detect_adapter
+      adapter_name = ActiveRecord::Base.connection.adapter_name.downcase
+
+      case adapter_name
+      when /postgresql/, /postgis/
+        :postgresql
+      when /mysql/, /trilogy/
+        :mysql
+      when /sqlite/
+        :sqlite
+      else
+        :fallback
+      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 mysql_contains(column, key, value = nil)
+      if value.present?
+        ["JSON_CONTAINS(#{column}, ?, ?)", value.to_json, "$.#{key}"]
+      else
+        ["JSON_CONTAINS_PATH(#{column}, 'one', ?)", "$.#{key}"]
+      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 normalize_sqlite_value(value)
+      return value unless value.is_a?(String)
+
+      if value.match?(INTEGER_PATTERN)
+        value.to_i
+      elsif value.match?(FLOAT_PATTERN)
+        value.to_f
+      else
+        value
+      end
+    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}%"]
+      else
+        escaped_key = key.to_s.gsub(/[%_\\]/) { |m| "\\#{m}" }
+        ["CAST(#{column} AS TEXT) LIKE ?", "%\"#{escaped_key}\"%"]
+      end
+    end
+
+    def extract_path(column, key)
+      raise ArgumentError, "Invalid JSON key: #{key.inspect}" unless key.to_s.match?(SAFE_KEY_PATTERN)
+
+      adapter = detect_adapter
+
+      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
+    end
+
+    def extract_path_not_null(column, key)
+      "#{extract_path(column, key)} IS NOT NULL"
+    end
+  end
+end

data/lib/rails_event_viewer/pagy_countable.rb

@@ -0,0 +1,31 @@
+module RailsEventViewer
+  class PagyCountable
+    def initialize(relation)
+      @relation = relation
+    end
+
+    def count(*)
+      @relation.count
+    end
+
+    def offset(value)
+      OffsetWrapper.new(@relation, value)
+    end
+
+    # Intermediate wrapper that captures offset and applies limit
+    class OffsetWrapper
+      def initialize(relation, offset_value)
+        @relation = relation
+        @offset_value = offset_value
+      end
+
+      def limit(value)
+        @relation.offset(@offset_value).limit(value).to_a
+      end
+
+      def to_a
+        @relation.offset(@offset_value).to_a
+      end
+    end
+  end
+end