julewire-rails 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 257bcc53a4cbe56820965e9fce773bda793b5c6f58e6bb336f8458809fe0a946
+  data.tar.gz: 3573b4e999ac109ec1f4ab4f80141ad0a27f12d87849468074161e94c96c8d1f
+SHA512:
+  metadata.gz: 654930df34fb73f8f2a8b599e1ccd966d06a0d73db00af1b4ac4e6edbaf3eca18bfa8c47adf6f314b73d20eceb76e9f6aaec839fa58df65744dab305966a3e4f
+  data.tar.gz: 16db8923eee46a3b948a5878ec2e1e4577562a42536a1b54e8a93c12b2944a50a207357927c6ac7226b873ee7f6ef8a8ae65c572e8e3f5cdd1d4cbc188338505

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+## Unreleased
+
+## 1.0.0 - 2026-06-21
+
+- Initial release: Rails request summaries, structured events, error capture,
+  parameter filtering, dev tail/doctor app, and Julewire logger.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Alexander Grebennik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,94 @@
+# Julewire Rails
+
+Rails integration for Julewire.
+
+It installs a Rails-compatible logger, wraps Rack requests in Julewire
+execution scopes, subscribes to Rails structured events, and records Rails error
+reports. It targets Rails 8.1 and newer.
+
+## Quickstart
+
+```ruby
+gem "julewire-rails"
+```
+
+Configure a Julewire output or custom destination:
+
+```ruby
+Julewire.configure do |config|
+  config.destinations.use(:default, output: $stdout)
+  config.level = :info
+
+  config.processors.prepend(
+    :rails_parameter_filter,
+    Rails.application.config.filter_parameters
+  )
+end
+```
+
+Or generate the initializer:
+
+```sh
+bin/rails generate julewire:install
+```
+
+Use normal Rails APIs:
+
+```ruby
+Rails.logger.info("booted")
+Rails.logger.warn(message: "retrying", event: "payment.retry", payment_id: 123)
+```
+
+Default behavior:
+
+- `Rails.logger.*` calls become Julewire point records.
+- Each request gets one `request.completed` summary.
+- Rails 8.1 structured events become machine point records.
+- `Rails.error` reports become `rails.error` point records.
+- Automatic request exceptions are owned by the request summary.
+- Rails default text subscribers are silenced when Julewire installs the Rails
+  logger.
+
+Request context stays small: request id, method, path, and remote IP. Rails
+routing, status, timings, completion, and optional capture fields live under
+`attributes.rails`.
+
+Rails filters structured event payloads before Julewire receives them.
+Whole-record filtering for `Rails.logger` payloads and optional captured fields
+is a Julewire processor policy; use the registered `:rails_parameter_filter`
+processor when Rails' `filter_parameters` should apply to the full Julewire
+record.
+
+## Docs
+
+- [Configuration](docs/configuration.md)
+- [Advanced Configuration](docs/advanced-configuration.md)
+- [Request Logging](docs/request-logging.md)
+- [Events and Errors](docs/events-and-errors.md)
+- [Capture and Filtering](docs/capture-and-filtering.md)
+- [Lifecycle](docs/lifecycle.md)
+- [Development](docs/development.md)
+
+## Local Doctor
+
+Mount the doctor app in development when you want a tiny health and tail view:
+
+```ruby
+tail = Julewire.dev!(tail: { capacity: 500 })
+mount Julewire::Rails::DoctorApp.new(tail: tail) => "/julewire"
+```
+
+The mounted app serves `/doctor`, `/doctor.json`, `/tail`, `/tail.json`, and a
+reconnecting `/tail/events` stream for the live tail page.
+
+The mounted app exposes health, tail buffers, and request paths. Gate it with
+environment, auth, IP rules, or an internal network boundary.
+
+Exclude the mount path from request summaries so the live tail does not capture
+its own polling requests:
+
+```ruby
+Julewire::Rails.configure do |config|
+  config.request_exclude_prefixes = ["/julewire"]
+end
+```

data/docs/advanced-configuration.md

@@ -0,0 +1,17 @@
+# Advanced Configuration
+
+These options are rarely needed for normal Rails apps.
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `logger_name` | `"Rails"` | Logger name on Rails logger records. |
+| `lifecycle_hooks` | `true` | Install at-exit and Rails fork hooks. |
+| `log_rescued_responses` | `:auto` | Control Rails raw rescued-response exception text. |
+| `reported_exception_logs` | `:auto` | Control raw `ActionDispatch::DebugExceptions` report text. |
+| `require_output` | `:warn` | Warn/raise when Julewire owns `Rails.logger` but has no output. |
+| `shutdown_timeout` | `1` | Timeout used by lifecycle flush/close hooks. |
+| `summary_event` | `"request.completed"` | Event name for request summaries. |
+
+`log_rescued_responses` and `reported_exception_logs` should usually stay on
+`:auto`. That lets Julewire suppress duplicate framework text when it owns the
+Rails logger while keeping Rails' own behavior when it does not.

data/docs/capture-and-filtering.md

@@ -0,0 +1,102 @@
+# Capture and Filtering
+
+Header and body capture is off by default. Captured fields are summary
+enrichment fields under `attributes.rails`.
+
+Response body capture reads the buffered `ActionDispatch::Response` body from
+`process_action.action_controller`. It does not consume or replace the Rack
+response body. File and stream-like responses are skipped. Streaming response
+bodies are not captured. Mounted Rack apps still get request summaries, but
+header and body capture requires a Rails controller `process_action` event.
+
+```ruby
+Julewire::Rails.configure do |config|
+  config.response_capture.body = true
+  config.response_capture.body_bytes = nil
+  config.response_capture.body_content_types = %w[application/json]
+end
+```
+
+Use `body = :json` to parse captured JSON into `request_body_json` or
+`response_body_json` instead of storing the raw body string. Truncated bodies
+are not parsed; invalid JSON records `*_body_parse_error`.
+When `body_bytes` is `nil`, `:json` mode parses the full captured body before
+core serialization limits apply.
+
+Captured response summaries include:
+
+- `response_body`
+- `response_body_json`
+- `response_body_parse_error`
+- `response_body_bytes`
+- `response_body_truncated`
+
+`*_body_bytes` is the content length when the framework provides it; otherwise
+it is the number of bytes observed while capturing.
+
+Request and response headers use `false`, `true`, or an explicit header list:
+
+```ruby
+Julewire::Rails.configure do |config|
+  config.request_capture.headers = true
+  config.response_capture.headers = %w[content-type x-request-id]
+  config.request_capture.body = true
+  config.request_capture.body_bytes = 65_536
+end
+```
+
+When header capture is `true`, Julewire omits common sensitive headers such as
+`authorization`, `cookie`, `set-cookie`, `proxy-authorization`, and
+`x-api-key`. Use an explicit header list if the application deliberately wants
+one of those fields.
+
+Captured request summaries can include:
+
+- `request_headers`
+- `response_headers`
+- `request_body`
+- `request_body_json`
+- `request_body_parse_error`
+- `request_body_bytes`
+- `request_body_truncated`
+
+Use processors before enabling broad header/body capture in an application with
+sensitive data.
+
+Body capture is gated by media type. The default captures `application/json`
+and `application/*+json` vendor media types. `true` means every non-file,
+buffered candidate. Binary media types such as `application/octet-stream`,
+images, audio, video, fonts, zip, gzip, and PDF are skipped even when body
+content types are set to `true`.
+
+Rails filters hash-based `Rails.event` payloads before subscribers receive
+them. Object event payloads are different: Rails passes the object through, and
+subscribers that serialize it must filter the serialized fields. Julewire Rails
+filters serialized object-event hashes with
+`Rails.application.filter_parameters` by default.
+
+For whole-record filtering, Rails' parameter filter can be installed as a
+Julewire processor:
+
+```ruby
+Julewire.configure do |config|
+  config.processors.prepend(
+    :rails_parameter_filter,
+    Rails.application.config.filter_parameters
+  )
+end
+```
+
+Record container fields such as `payload`, `attributes`, and `context` keep
+their Julewire shape even when a filter matches the section name.
+
+Filtering layers:
+
+| Layer | Scope |
+| --- | --- |
+| Rails event filtering | Serialized object event payloads before the Julewire record is built. |
+| `ParameterFilterProcessor` | Whole Julewire records using Rails parameter filter rules. |
+| Custom processors | Whole Julewire records using application policy. |
+
+If more than one whole-record processor is installed, normal Julewire processor
+order decides precedence.

data/docs/configuration.md

@@ -0,0 +1,83 @@
+# Configuration
+
+Rails config lives on `Julewire::Rails.config` and on
+`config.julewire_rails` in a Rails application.
+
+When Julewire owns `Rails.logger`, Rails logger calls are gated by
+`Rails.logger.level`. They bypass core `Julewire.config.level` because the Rails
+logger already applied its level check. Direct `Julewire.emit` and severity
+helper calls still use core `Julewire.config.level`.
+
+## Default Path
+
+These defaults are intended for a normal Rails app:
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `logger` | `true` | Install Julewire as `Rails.logger`. |
+| `request_middleware` | `true` | Wrap Rack requests in Julewire executions. |
+| `request_summary` | `true` | Emit one `request.completed` summary per request. |
+| `request_context` | `true` | Add request id, method, path, and remote IP to context. |
+| `structured_events` | `true` | Subscribe to selected Rails structured events. |
+| `error_reports` | `true` | Subscribe to `Rails.error` reports. |
+| `source` | `"rails"` | Source value on Rails records. |
+| `silence_log_subscribers` | `:auto` | Silence Rails default text subscribers when Julewire owns `Rails.logger`. |
+| `replace_rack_logger` | `true` | Replace `Rails::Rack::Logger` with Julewire request middleware. |
+
+## Common Knobs
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `carry_request_headers` | `false` | Explicit request-header list copied into `Julewire.carry`. |
+| `request_exclude_prefixes` | `[]` | Request path prefixes that bypass Julewire request context and summaries. |
+| `request_summary_timeout` | `30` | Seconds before warning that body close/completion is late. It does not finish the summary. |
+| `request_capture.headers` | `false` | Add selected request headers to `attributes.rails` on summaries. |
+| `request_capture.body` | `false` | Add request body fields to `attributes.rails` on summaries. |
+| `response_capture.headers` | `false` | Add selected response headers to `attributes.rails` on summaries. |
+| `response_capture.body` | `false` | Add response body fields to `attributes.rails` on summaries. |
+| `filter_event_payloads` | `true` | Filter serialized object-event hashes with Rails parameter filters. |
+| `rendered_exceptions` | `false` | Emit diagnostic rendered-exception point records in addition to summaries. |
+
+Broad header capture (`*.headers = true`) skips common sensitive headers.
+Explicit header lists are authoritative.
+
+`structured_event_prefixes = nil` accepts all structured-event names. Use it
+only when the app wants Julewire to consider every Rails event.
+
+Capture sub-options:
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `*.headers` | `false` | `false`, `true`, or explicit header names. |
+| `*.body` | `false` | `true` captures raw buffered bodies; `:json` parses bodies into `*_body_json`. |
+| `*.body_bytes` | `65_536` | Body byte cap; `nil` means no cap. |
+| `*.body_content_types` | `Julewire::Rack::Capture::BodyContentType::JSON_ONLY` | Media-type allowlist; `true` means all non-binary buffered bodies. |
+
+## Structured Events
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `structured_event_prefixes` | `["action_controller.", "action_dispatch.", "active_record."]` | Rails event prefixes. |
+| `structured_event_names` | `[]` | Exact event names to emit. |
+| `structured_event_exclude_prefixes` | `[]` | Prefixes to suppress. |
+| `structured_event_exclude_names` | `[]` | Exact names to suppress. |
+
+`action_view.` is opt-in because Rails exposes every render start, partial,
+collection, layout, and template as structured events.
+
+```ruby
+Julewire::Rails.configure do |config|
+  config.structured_event_names = %w[action_view.render_template]
+end
+```
+
+Example:
+
+```ruby
+Julewire::Rails.configure do |config|
+  config.carry_request_headers = %w[traceparent tracestate]
+  config.request_exclude_prefixes = ["/julewire"]
+  config.response_capture.body = :json
+  config.response_capture.body_content_types = %w[application/json]
+end
+```

data/docs/development.md

@@ -0,0 +1,21 @@
+# Development
+
+Run the normal gem checks:
+
+```sh
+bundle exec rake
+```
+
+Run the Rails appraisal suite:
+
+```sh
+bundle exec rake appraisal:test
+BUNDLE_GEMFILE=gemfiles/rails_8_1.gemfile bundle exec rake test
+BUNDLE_GEMFILE=gemfiles/rails_head.gemfile bundle exec rake test
+```
+
+The real-stack tests live under `test/dummy` and exercise a booted Rails app,
+default log-subscriber silencing, Rails structured events, logger calls, request
+summaries, and body-capture media gates. Add future Rails versions by adding
+another gemfile under `gemfiles/` and adding it to `RAILS_APPRAISAL_TARGETS`.
+`rails_head` tracks the Rails repository's default branch.

data/docs/events-and-errors.md

@@ -0,0 +1,46 @@
+# Events and Errors
+
+Rails 8.1 structured events are subscribed through `Rails.event`. Controller
+start/completion events enrich the request summary. Framework events such as SQL
+and render notifications are emitted as point records.
+
+Rails default text log subscribers are silenced by default when Julewire owns the
+Rails logger. Anything that still reaches `Rails.logger` is treated as a logger
+call, not parsed as duplicate framework text.
+
+To keep Rails' default logger output and use Julewire only for request summaries
+or structured-event records:
+
+```ruby
+Julewire::Rails.configure do |config|
+  config.logger = false
+  config.request_middleware = true
+  config.structured_events = true
+end
+```
+
+When `request_summary` is enabled, rendered 4xx/5xx request errors are attached
+to `request.completed`. The summary includes the Rails response status,
+`error_class`, `rescue_response`, and `rescue_template`, plus the core-shaped
+exception.
+
+Request-error summary severity inherits Rails'
+`action_dispatch.debug_exception_log_level`. Julewire does not derive this
+severity from the status code.
+
+Backtrace policy is owned by core:
+
+```ruby
+Julewire.configure do |config|
+  config.error_backtrace_lines = 0
+end
+```
+
+Set `rendered_exceptions = true` only when you want an additional diagnostic
+point record from `ActionDispatch::DebugExceptions` alongside the summary-owned
+request error.
+
+`Rails.error` remains a separate source for explicit application reports,
+handled reports, jobs, and framework errors that are not owned by a request
+summary. Julewire records those as `rails.error` and shapes the exception
+through core's exception serializer.

data/docs/lifecycle.md

@@ -0,0 +1,24 @@
+# Lifecycle
+
+When `lifecycle_hooks` is enabled, the Railtie installs an at-exit drain hook
+that flushes and closes Julewire with `shutdown_timeout`.
+
+It also registers a Rails `ActiveSupport::ForkTracker` after-fork hook that:
+
+- calls `Julewire.after_fork!`
+- resets request-summary timeout scheduler state
+- clears request-error ownership state
+
+This covers Rails process forks that go through Rails' fork tracker.
+
+Custom destinations still own queue, retry, delivery, and reopen behavior. The
+Rails hook only gives them lifecycle opportunities.
+
+`require_output` checks after Rails initializers that Julewire has at least one
+configured destination when Julewire owns `Rails.logger`.
+
+| Value | Behavior |
+| --- | --- |
+| `:warn` | Warn, but allow no-output mode. |
+| `:raise` | Fail boot if no output is configured. |
+| `false` | Do not check. |

data/docs/request-logging.md

@@ -0,0 +1,49 @@
+# Request Logging
+
+The request middleware replaces `Rails::Rack::Logger`, wraps each Rack request
+in a Julewire execution scope, and emits one request summary when enabled.
+
+Rails emits five Julewire record shapes:
+
+| Source | Shape |
+| --- | --- |
+| Rails structured events | Point records such as `active_record.sql`. |
+| `Rails.logger.*` | Point records with `event: "log"`. |
+| Request boundary | One `request.completed` summary. |
+| `Rails.error` | Explicit `rails.error` point records. |
+| Rendered exception interceptor | Optional diagnostic point records. |
+
+`Rails.logger` records intentionally do not honor user-supplied `kind`,
+`execution`, `carry`, `attributes`, or `neutral` keys. Those keys are treated as
+payload data so ordinary logger calls cannot forge execution identity,
+propagation state, or formatter coordination fields.
+
+Request ids, method, path, and remote IP stay in `context`. Rails-specific
+routing and diagnostics such as controller, action, format, params, status,
+filtered URL/path, timings, completion, and capture fields live under
+`attributes.rails`.
+
+Provider-neutral HTTP fields live in the record's `neutral` section for
+formatters:
+
+- `http.request.method`
+- `url.full`
+- `url.path`
+- `user_agent.original`
+- `client.address`
+- `http.response.status_code`
+- `http.response.body.size`
+
+The request summary emits at Rack response completion when Rails/Rack exposes a
+completion hook, or when the wrapped response body closes. If neither happens,
+`request_summary_timeout` emits a `request.completion_timeout` warning point
+with `completion_timeout_ms`. It does not finish the request summary from the
+timeout thread; a later body close can still emit the normal summary.
+
+`ActionController::Live` child-thread execution does not inherit Julewire
+context by itself. Live needs an explicit bridge through Rails execution state.
+
+Julewire Rails supports Rails' default
+`config.action_dispatch.show_exceptions = :all`. `:rescuable` and `:none` let
+some or all exceptions escape to the Rack server and are not supported modes for
+Julewire Rails request logging.

data/julewire-rails.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "lib/julewire/rails/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "julewire-rails"
+  spec.version = Julewire::Rails::VERSION
+  spec.authors = ["Alexander Grebennik"]
+  spec.email = ["slbug@users.noreply.github.com", "sl.bug.sl@gmail.com"]
+
+  spec.summary = "Rails logger and request runtime integration for Julewire."
+  spec.description = "Rails 8.1+ integration that routes Rails.logger through Julewire and wraps requests in " \
+                     "execution scopes."
+  spec.homepage = "https://github.com/slbug/julewire"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.4"
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/slbug/julewire/tree/main/gems/rails"
+  spec.metadata["changelog_uri"] = "https://github.com/slbug/julewire/blob/main/gems/rails/CHANGELOG.md"
+
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    Dir[
+      "CHANGELOG.md",
+      "LICENSE.txt",
+      "README.md",
+      "docs/**/*.md",
+      "julewire-rails.gemspec",
+      "lib/**/*.rb"
+    ]
+  end
+  spec.executables = []
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "actionpack", ">= 8.1"
+  spec.add_dependency "actionview", ">= 8.1"
+  spec.add_dependency "julewire-core", ">= 1.0"
+  spec.add_dependency "julewire-rack", ">= 1.0"
+  spec.add_dependency "julewire-rails_support", ">= 1.0"
+  spec.add_dependency "logger", ">= 1.7"
+  spec.add_dependency "railties", ">= 8.1"
+  spec.add_dependency "zeitwerk", ">= 2.8.1"
+end

data/lib/generators/julewire/install_generator.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module Julewire
+  module Generators
+    class InstallGenerator < ::Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      def copy_initializer
+        template "julewire.rb", "config/initializers/julewire.rb"
+      end
+    end
+  end
+end

data/lib/generators/julewire/templates/julewire.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+Julewire.configure do |config|
+  config.destinations.use(:default, output: $stdout) if config.destinations.empty?
+
+  config.processors.prepend(
+    :rails_parameter_filter,
+    Rails.application.config.filter_parameters
+  )
+end
+
+Julewire::Rails.configure do |config|
+  config.request_summary = true
+  config.structured_events = true
+  config.error_reports = true
+end

data/lib/julewire/rails/configuration.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Julewire
+  module Rails
+    class Configuration
+      include Julewire::Core::Integration::Settings
+
+      setting :logger, default: true, predicate: true
+      setting :logger_name, default: "Rails"
+      setting :carry_request_headers, default: false, validate: :validate_carry_request_headers
+      setting :error_reports, default: true, predicate: true
+      setting :filter_event_payloads, default: true, predicate: true
+      setting :lifecycle_hooks, default: true, predicate: true
+      setting :log_rescued_responses, default: :auto
+      setting :reported_exception_logs, default: :auto
+      setting(:request_capture, validate: :validate_capture_settings) { Julewire::Rack::Capture::Settings.new }
+      setting :request_context, default: true, predicate: true
+      setting :request_exclude_prefixes, default: [], validate: :validate_request_exclude_prefixes
+      setting :request_middleware, default: true, predicate: true
+      setting :require_output, default: :warn
+      setting :request_summary, default: true, predicate: true
+      setting :request_summary_timeout, default: 30, validate: :validate_request_summary_timeout
+      setting :replace_rack_logger, default: true, predicate: true
+      setting(:response_capture, validate: :validate_capture_settings) { Julewire::Rack::Capture::Settings.new }
+      setting :rendered_exceptions, default: false, predicate: true
+      setting :silence_log_subscribers, default: :auto
+      setting :shutdown_timeout, default: 1
+      setting :source, default: "rails"
+      setting :structured_event_exclude_names, default: []
+      setting :structured_event_exclude_prefixes, default: []
+      setting :structured_event_names, default: []
+      setting :structured_event_prefixes, default: %w[action_controller. action_dispatch. active_record.]
+      setting :structured_events, default: true, predicate: true
+      setting :summary_event, default: "request.completed"
+
+      def controller_capture?
+        request_capture.enabled? || response_capture.enabled?
+      end
+
+      def silence_log_subscribers?
+        return logger? if silence_log_subscribers == :auto
+
+        !!silence_log_subscribers
+      end
+
+      private
+
+      def validate_carry_request_headers(value)
+        return value unless value == true
+
+        raise Error, "carry_request_headers must be an explicit header list"
+      end
+
+      def validate_request_summary_timeout(value)
+        return value if value.nil?
+        return value if value.is_a?(Numeric) && value.positive?
+
+        raise Error, "request_summary_timeout must be nil or a positive Numeric"
+      end
+
+      def validate_request_exclude_prefixes(value)
+        prefixes = Array(value)
+        return prefixes if prefixes.all? { it.is_a?(String) && it.start_with?("/") && !it.empty? }
+
+        raise Error, "request_exclude_prefixes must contain absolute path prefixes"
+      end
+
+      def validate_capture_settings(settings)
+        settings.validate!
+        settings
+      end
+    end
+  end
+end