rails_event_viewer 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 323623721d960260a7ea2077cf30edc17c4708b7c8d96ab5d9fc7320b45f8113
-  data.tar.gz: 7afbd0a2835c53520bbbb8d1f323b1643297bc8e641948c614ddc407d6791edd
+  metadata.gz: ef30fa1ce21c1dc5c6eaa4634707801f2d32b67ab561231865cc67c0eb2c557f
+  data.tar.gz: 9a423c1745dfb3a088137fbe4c912c069a1e65ca68afc0e4d1dac2961819baac
 SHA512:
-  metadata.gz: f28f9dff6c4085b5c319744f19c71ae1f373dede9add4a8f5a0bda335bb088ec283e353c151cd28eb5ae71ba2d9b4a6f8c13f45bb7a03d62b687ba706b405ff9
-  data.tar.gz: 544807b6dbee7af798bce690b6b51e0ada6f168b7681d867d2b57ce634aa3995b1878ba3f3e3dbe3976d6ce55edf9bb6f069f1b4b2722988154b97b86164103c
+  metadata.gz: 3b25d996bb14c0bada11737d07a98f93fbd10b8f4781ea3163b79185e31a2b6fe30a99b74e69f63e1d6e768a1fa137124bab9f3a47da07f5940466de1933e2ff
+  data.tar.gz: 828ddff25e0930d10bc34c75ee58e789f361f6dc14c3bf24c56b463e8b1327b454cf15ce7536f7d32969716f4c6db82bd9640c3bfcada4a8c9aed072132bc158

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## 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.
+- Page links now keep the active filters, search query, and `per_page`. Previously every page link dropped them, so page 2 of a filtered list showed unfiltered results.
+- A page number past the end now shows the last page instead of an empty one.
+
+## 0.1.1 (2026-09-30)
+
+- The dashboard now works under a strict Content Security Policy. Tailwind CSS is compiled into the gem, and Chart.js, its date adapter, and Chartkick are served from the host app with CSP nonces instead of from CDNs.
+- Replaced inline `onclick` handlers and inline `style` attributes with data attributes and a small bundled script, so clickable rows, the payload Copy button, chart sizing, and progress bars work without `unsafe-inline`.
+- The dashboard no longer loads the host app's importmap JavaScript.
+- Fixed event type and group pages for names and values containing dots, such as `order.placed` or `alice@example.com`. Rails was reading the part after the dot as a format, so these pages rendered empty.
+- Ruby 3.3 or newer is required.
+
 ## 0.1.0 (2026-09-29)
 
 Initial release.

data/README.md

@@ -1,451 +1,136 @@
 # RailsEventViewer
 
-A Rails engine for viewing and analyzing events emitted via `Rails.event`.
-Provides a web UI dashboard for browsing, filtering, and visualizing domain events in your Rails application.
-
-## Features
-
-- Web-based dashboard for viewing events
-- Flexible storage adapters (ActiveRecord, Redis, Memory, or custom)
-- High-performance buffered ingestion with configurable batch writes
-- Fluent query interface for programmatic access
-- Event filtering by name, tags, and time range
-- Full-text search across event names and payloads
-- Analytics with event counts over time
-- Configurable retention and automatic cleanup
-- HTTP Basic Auth or custom authentication
+A Rails engine that captures events emitted with `Rails.event` and gives you a dashboard to browse, search, and chart them.
 
 ## Requirements
 
 - Rails 8.1+
-- Ruby 3.2+
+- Ruby 3.3+
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
 ```ruby
 gem "rails_event_viewer"
 ```
 
-And then execute:
-
 ```bash
 bundle install
-```
-
-Run the install generator:
-
-```bash
 rails generate rails_event_viewer:install
-```
-
-This will:
-- Create a migration for the events table (if using ActiveRecord adapter)
-- Create an initializer with configuration options
-- Mount the engine at `/events`
-
-Run the migration:
-
-```bash
-rails db:migrate
-```
-
-## Configuration
-
-Configure RailsEventViewer in `config/initializers/rails_event_viewer.rb`:
-
-```ruby
-RailsEventViewer.configure do |config|
-  # Storage adapter: :active_record, :redis, :memory, :null, or a custom class
-  config.storage_adapter = :active_record
-
-  # Adapter-specific options
-  config.adapter_options = {}
-
-  # Performance settings
-  config.async = true              # Enable buffered writes
-  config.buffer_size = 100         # Flush after N events
-  config.flush_interval = 2        # Flush every N seconds
-  config.sample_rate = 1.0         # 1.0 = capture all, 0.1 = capture 10%
-
-  # Retention
-  config.retention_period = 7.days
-
-  # Filtering
-  config.captured_events = []      # Empty = capture all
-  config.ignored_events = []       # Events to never capture
-
-  # UI settings
-  config.per_page = 25
-
-  # Authentication (choose one)
-  config.http_basic_auth_enabled = true
-  config.http_basic_auth_user = ENV["RAILS_EVENT_VIEWER_USER"]
-  config.http_basic_auth_password = ENV["RAILS_EVENT_VIEWER_PASSWORD"]
-
-  # Or use custom authentication
-  config.authentication = ->(controller) {
-    controller.authenticate_user!
-    controller.current_user.admin?
-  }
-end
-```
-
-## Storage Adapters
-
-### ActiveRecord (default)
-
-Stores events in your database. Best for most applications with full analytics support.
-
-```ruby
-config.storage_adapter = :active_record
-```
-
-The install generator creates the migration for you. If you skipped the generator, copy the migration from the engine instead. Do not do both, or you will get two migrations for the same table.
-
-```bash
-rails rails_event_viewer:install:migrations
 rails db:migrate
 ```
 
-### Redis
-
-Stores events in Redis sorted sets. Good for high-volume, ephemeral storage where you don't need long-term persistence.
-
-First, add the redis gem to your Gemfile:
-
-```ruby
-gem "redis"
-```
-
-Then configure the adapter:
-
-```ruby
-config.storage_adapter = :redis
-config.adapter_options = {
-  redis_options: { url: ENV.fetch("REDIS_URL", "redis://localhost:6379") },
-  pool_size: 5,
-  key_prefix: "rails_event_viewer",
-  max_events: 10_000
-}
-```
-
-Options:
-- `redis_options` - Hash passed to `Redis.new` whenever the pool opens a new connection (default: `{}`)
-- `pool_size` - Number of pooled Redis connections, should match your app's thread count (default: `5`)
-- `pool_timeout` - Seconds to wait for a free connection before raising (default: `5`)
-- `key_prefix` - Prefix for Redis keys (default: `"rails_event_viewer"`). The adapter wraps it in braces, so keys look like `{rails_event_viewer}:events`. The braces are a Redis Cluster hash tag that keeps every key on one node, which the adapter's multi-key commands require. Do not add braces yourself.
-- `max_events` - Maximum events to retain, older events are automatically trimmed (default: `10_000`)
-
-The adapter uses a connection pool rather than a single shared connection, since one Redis connection is not safe to use concurrently across multiple threads. Each pooled connection is built independently from `redis_options`. Pass `pool:` with your own `ConnectionPool` for full control.
-
-Note: Redis adapter performs analytics by fetching events into memory, which may be slower than ActiveRecord for large datasets.
-
-Filtered queries and analytics scan every stored event. Keep `max_events` modest, around 10,000, if you filter often.
-
-### Memory
-
-In-memory storage for development and testing.
-
-```ruby
-config.storage_adapter = :memory
-config.adapter_options = { max_events: 1000 }
-```
-
-Options:
-- `max_events` - Maximum events to retain (default: `1000`)
-
-Note: Events are lost when the server process restarts. Not recommended for production use.
-
-### Null
-
-Discards all events. Useful for disabling event capture in specific environments.
-
-```ruby
-config.storage_adapter = :null
-```
+The generator creates the migration and an initializer, and mounts the dashboard at `/events`.
 
-### Switching Adapters via Environment Variable
+## Usage
 
-A common pattern is to use different adapters per environment:
+Emit events with the standard Rails API. RailsEventViewer subscribes automatically.
 
 ```ruby
-RailsEventViewer.configure do |config|
-  adapter = ENV.fetch("EVENT_STORAGE", "active_record").to_sym
-  config.storage_adapter = adapter
-
-  case adapter
-  when :redis
-    config.adapter_options = {
-      redis_options: { url: ENV.fetch("REDIS_URL", "redis://localhost:6379") },
-      max_events: 10_000
-    }
-  when :memory
-    config.adapter_options = { max_events: 1000 }
-  end
-end
-```
-
-Then switch adapters when starting your server:
-
-```bash
-# Use ActiveRecord (default)
-bin/rails server
-
-# Use Redis
-EVENT_STORAGE=redis bin/rails server
-
-# Use Memory
-EVENT_STORAGE=memory bin/rails server
+Rails.event.notify("order.placed", order_id: order.id, total: order.total)
 ```
 
-### Custom Adapter
-
-Create your own adapter by including the `RailsEventViewer::Adapter` module:
+Query them from code:
 
 ```ruby
-class MyCustomAdapter
-  include RailsEventViewer::Adapter
-
-  def write_events(events)
-  end
-
-  def fetch_events(relation)
-  end
-
-  def count_events(relation)
-  end
-
-  def distinct_event_names
-  end
-
-  def find_event(id)
-  end
-
-  def delete_before(timestamp)
-  end
-
-  def distinct_group_values(key, source: :context)
-  end
-
-  def group_instances(key, source: :context, limit: 100)
-  end
-
-  def events_over_time(since:, interval:)
-    # Return { time => count }
-  end
-
-  def counts_by_name(limit:)
-    # Return { name => count }, highest first
-  end
-
-  def count_since(since)
-    # Return count of events since a time
-  end
-end
-
-config.storage_adapter = MyCustomAdapter
-```
-
-## Emitting Events
-
-RailsEventViewer automatically subscribes to `Rails.event`. Emit events using the standard Rails API:
-
-```ruby
-Rails.event.notify("user.created", user_id: user.id, email: user.email)
-
-Rails.event.notify(
-  "order.placed",
-  order_id: order.id,
-  total: order.total,
-  tags: { environment: Rails.env, priority: "high" }
-)
-```
-
-## Programmatic Access
-
-Use the fluent query interface to access events:
-
-```ruby
-# Get all events
-RailsEventViewer.events.each { |e| puts e[:name] }
-
-# Filter by name
-RailsEventViewer.events.with_name("user.created").to_a
-
-# Filter by tag
-RailsEventViewer.events.with_tag(:environment, "production").to_a
-
-# Time range
-RailsEventViewer.events.since(1.hour.ago).until(30.minutes.ago).to_a
-
-# Search
-RailsEventViewer.events.search("user@example.com").to_a
-
-# Combine filters
 RailsEventViewer.events
   .with_name("order.placed")
   .with_tag(:priority, "high")
   .since(1.day.ago)
   .limit(50)
-  .each { |e| process(e) }
-
-# Count
-RailsEventViewer.events.with_name("user.created").count
-
-# Pagination
-RailsEventViewer.events.offset(25).limit(25).to_a
-```
-
-## Rake Tasks
-
-```bash
-# Show statistics
-bin/rails rails_event_viewer:stats
-
-# Clean up old events (based on retention_period)
-bin/rails rails_event_viewer:cleanup
-
-# Flush buffered events
-bin/rails rails_event_viewer:flush
-
-# Clear all events (interactive confirmation required)
-bin/rails rails_event_viewer:clear
-```
-
-For automatic cleanup, add to your scheduler:
-
-```yaml
-# config/recurring.yml (Solid Queue)
-production:
-  rails_event_viewer_cleanup:
-    command: "RailsEventViewer.adapter.delete_before(RailsEventViewer.retention_period.ago)"
-    schedule: every day at 3am
+  .to_a
 ```
 
-Or using the whenever gem:
-
-```ruby
-# config/schedule.rb (whenever gem)
-every 1.day, at: "3:00 am" do
-  rake "rails_event_viewer:cleanup"
-end
-```
+Other filters: `with_context`, `search`, `until`, `offset`, and `count`.
 
-## Event Filtering
+## Configuration
 
-Control which events are captured:
+`config/initializers/rails_event_viewer.rb`:
 
 ```ruby
-# Only capture specific events
-config.captured_events = ["user.created", "order.placed"]
+RailsEventViewer.configure do |config|
+  config.storage_adapter = :active_record  # :active_record, :redis, :memory, :null, or a class
 
-# Or use regex patterns
-config.captured_events = [/^user\./, /^order\./]
+  config.async = true                       # buffer writes in a background thread
+  config.buffer_size = 100                  # flush after this many events
+  config.flush_interval = 2                 # or after this many seconds
+  config.sample_rate = 1.0                  # 0.1 keeps 10% of events
 
-# Ignore specific events
-config.ignored_events = ["internal.heartbeat", /^debug\./]
+  config.captured_events = []               # empty captures everything
+  config.ignored_events += [/^debug\./]     # strings or regexes
+  config.retention_period = 7.days          # used by the cleanup task
+end
 ```
 
-## Sampling
-
-For high-volume applications, reduce storage by sampling if needed:
-
-```ruby
-# Capture only 10% of events
-config.sample_rate = 0.1
-```
+Internal Rails events such as `active_record.*` and `action_controller.*` are ignored by default. Remove a pattern from `ignored_events` to capture it.
 
 ## Authentication
 
-If neither option below is configured, the dashboard is open in development and test, and returns `403 Forbidden` in every other environment, including staging. Enabling HTTP Basic Auth with a blank user or password also returns `403 Forbidden`.
-
-Set `RAILS_ENV` on every deployed server. If it is missing, Rails falls back to development and the dashboard is open.
-
-### HTTP Basic Auth
+Without authentication, the dashboard is open in development and test, and returns `403` everywhere else.
 
 ```ruby
 config.http_basic_auth_enabled = true
 config.http_basic_auth_user = ENV["RAILS_EVENT_VIEWER_USER"]
 config.http_basic_auth_password = ENV["RAILS_EVENT_VIEWER_PASSWORD"]
-```
 
-### Custom Authentication
-
-```ruby
-# Devise example
+# or
 config.authentication = ->(controller) {
   controller.authenticate_user!
   controller.current_user.admin?
 }
 ```
 
-## Routes
-
-The engine is mounted at the path specified in your routes (default `/events`):
-
-```ruby
-# config/routes.rb
-mount RailsEventViewer::Engine, at: "/events"
-```
+Set `RAILS_ENV` on every server. Without it, Rails falls back to development and the dashboard is open.
 
-Available routes:
-- `/events` - Dashboard
-- `/events/events` - Event list with filtering
-- `/events/events/:id` - Single event detail
-- `/events/analytics/overview` - Analytics dashboard
-- `/events/groups` - Event groups
+## Storage adapters
 
-## How Event Capture Works
+| Adapter | Use it for |
+|---|---|
+| `:active_record` | The default. Stores events in your database, with full analytics. |
+| `:redis` | High volume, short-lived storage. Keeps the newest `max_events`. |
+| `:memory` | Development and tests. Lost on restart. |
+| `:null` | Disables storage. |
 
-RailsEventViewer subscribes to `Rails.event` (the Structured Event Reporter introduced in Rails 8.1),
-which is built on top of `ActiveSupport::Notifications`. This means internal Rails instrumentation
-events (`sql.active_record`, `process_action.action_controller`, etc.) are received by the subscriber.
+Redis needs the `redis` gem:
 
-By default, all internal Rails framework events are excluded via the built-in `ignored_events` patterns.
-This prevents noise from flooding your storage.
+```ruby
+config.storage_adapter = :redis
+config.adapter_options = {
+  redis_options: { url: ENV["REDIS_URL"] },
+  pool_size: 5,
+  max_events: 10_000
+}
+```
 
-**Captured by default:**
-- Application events emitted via `Rails.event.notify("my.event", ...)`
+Filtered queries on Redis scan every stored event, so keep `max_events` modest.
 
-**Ignored by default** (via `ignored_events`):
-- `active_record.*`, `action_controller.*`, `action_view.*`, `active_job.*`
-- `action_mailer.*`, `active_storage.*`, `action_cable.*`, `rails.*`
-- `turbo.*`, `cache_*`, `*.sql`, `solid_*`
+For a custom adapter, include `RailsEventViewer::Adapter` and implement the methods it lists.
 
-To capture internal Rails events, remove the relevant pattern from `ignored_events`:
+## Rake tasks
 
-```ruby
-RailsEventViewer.configure do |config|
-  config.ignored_events = RailsEventViewer.ignored_events.reject { |p| p == /^active_record\./ }
-end
+```bash
+bin/rails rails_event_viewer:stats     # counts and top events
+bin/rails rails_event_viewer:cleanup   # delete events older than retention_period
+bin/rails rails_event_viewer:flush     # write buffered events now
+bin/rails rails_event_viewer:clear     # delete everything, asks first
 ```
 
-## Development
+Schedule `cleanup` daily, for example with Solid Queue in `config/recurring.yml`:
 
-After checking out the repo, run:
-
-```bash
-cd test/dummy
-bin/rails db:migrate
-bin/rails server
+```yaml
+production:
+  rails_event_viewer_cleanup:
+    command: "RailsEventViewer.adapter.delete_before(RailsEventViewer.retention_period.ago)"
+    schedule: every day at 3am
 ```
 
-Run the test suite:
+## Development
 
 ```bash
+bundle install
 bundle exec rake test
+cd test/dummy && bin/rails db:migrate && bin/rails server
 ```
 
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b feature/my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin feature/my-new-feature`)
-5. Create a Pull Request
-
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+MIT.

data/app/assets/javascripts/rails_event_viewer/application.js

@@ -0,0 +1,28 @@
+document.addEventListener("DOMContentLoaded", () => {
+  document.querySelectorAll("[data-event-viewer-width]").forEach((bar) => {
+    bar.style.width = `${bar.dataset.eventViewerWidth}%`
+  })
+})
+
+document.addEventListener("click", (event) => {
+  const copyButton = event.target.closest("[data-event-viewer-copy]")
+  if (copyButton) {
+    if (!navigator.clipboard || copyButton.dataset.eventViewerCopied) return
+
+    navigator.clipboard.writeText(copyButton.dataset.eventViewerCopy).then(() => {
+      const label = copyButton.textContent
+      copyButton.dataset.eventViewerCopied = "true"
+      copyButton.textContent = "Copied!"
+      setTimeout(() => {
+        copyButton.textContent = label
+        delete copyButton.dataset.eventViewerCopied
+      }, 1500)
+    })
+    return
+  }
+
+  const row = event.target.closest("[data-event-viewer-href]")
+  if (row && !event.target.closest("a, button")) {
+    window.location = row.dataset.eventViewerHref
+  }
+})