require-profiler 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e11b353825774069b1dea2916f61688970a61ea00e59c54ccd68d39e311f452
-  data.tar.gz: 1580e8719935ec0d70d98f48fdad60207e777a475a86640e9d1cdac390993329
+  metadata.gz: 9f7525e2f089705293ecb70a35d28837fb45c144b9c58861c9904d8b58a9e49a
+  data.tar.gz: 8a5e2acb8665b0bb7d665d91d0598d16c61d7488f7d40bed23cc1afe03559e7a
 SHA512:
-  metadata.gz: ce85f247ab89347bbd51a609e10254bd1aaf485ae892476a3e67fb722f5037d68b76a153560e8172ea2c9b605aafc005f7accb35a11e77913eba9b7d80616974
-  data.tar.gz: c0897c79cb3cf3bca1c612d9794ebd00f8ff3d295d98b2faf664190f4bc6d0ba235e01b11a06e3edb7f79197db848d2923b15ae34850cdb9b2febf0349219877
+  metadata.gz: ef22d5d6c1a8d98bc7418802be6b95f9a84e82336e4f1de1681cddfba631ca187c504ccf343d2ea25832b46ca1a6c00bd411996bb8c77315a6f0311a4c5895dd
+  data.tar.gz: ae0f1a579693c2242f78eab1f4898e94ed54701ff8d3cc4d080b534791f9043206da1d89ef2da58cf5dcd67fc27404bcf0e2b0aae15d14e67d9f2a3a8c3a0812

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## master
 
+## 0.3.0 (2026-07-23)
+
+- Add Rails initialization tracking: railtie initializers, `to_prepare` callbacks, and lazy load hooks. ([@ardecvz][])
+
+- Prefix HTTP nodes with `http:`. ([@ardecvz][])
+
+## 0.2.3 (2026-06-05)
+
+- Add SKILL.md for rails-hyperdrive. ([@palkan][])
+
+## 0.2.2 (2026-06-05)
+
+- Fixed YAML tracking when Pathname is used. ([@palkan][])
+
 ## 0.2.1 (2026-05-26)
 
 - Add YAML tracking. ([@palkan][])

data/README.md

@@ -7,8 +7,9 @@ Require Profiler is a tool for profiling Ruby's code loading—`Kernel#require`,
 
 It's built on top of [Require Hooks][require-hooks], so it works anywhere Require Hooks does (MRI/JRuby/TruffleRuby).
 
-<a href="https://evilmartians.com/">
-<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+<br/>
+
+<img src="https://cdn.evilmartians.com/badges/logo-no-label.svg" alt="Evil Martians logo" width="22" height="16" /> <b>Require Profiler</b> is built by <b><a href="https://evilmartians.com/">Evil Martians</a></b>, an American design and engineering consultancy for <b>developer tools, AI, and cybersecurity startups</b>.
 
 ## Installation
 
@@ -112,6 +113,14 @@ Now you can use Speedscope to dig deeper.
 
 Require Profiler also captures HTTP requests and YAML file loading and add them to the profile, so you can find which Ruby files trigger the corresponding actions on load. NOTE: For HTTP requests tracking, you MUST add [sniffer][] gem to your Gemfile.
 
+Disable with `REQUIRE_PROFILER_YAML=false` or `REQUIRE_PROFILER_HTTP=false`.
+
+### Rails integration
+
+When Rails is loaded, Require Profiler automatically captures its initialization - railtie initializers, `to_prepare` callbacks, and lazy load hooks - and adds them to the profile as `initializer:`, `to_prepare:`, and `load_hook:` nodes, so you can find the slow-running blocks, which are usually invisible when profiling code loading alone.
+
+Disable with `REQUIRE_PROFILER_RAILS=false` (or set a threshold if the extra nodes add too much noise).
+
 ### Configuration
 
 `RequireProfiler.start` accepts the following keyword arguments:

data/lib/require_profiler/patcher.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RequireProfiler
+  # Use TracePoint to run a callback when a particular class is defined
+  module Patcher
+    class << self
+      def on_load(name, &callback)
+        return callback.call if Object.const_defined?(name)
+
+        callbacks[name] = callback
+
+        tracer.enable
+      end
+
+      private
+
+      def callbacks = @callbacks ||= {}
+
+      def tracer = @tracer ||= TracePoint.new(:end, &method(:on_class))
+
+      def name_method = @name_method ||= Module.instance_method(:name)
+
+      def on_class(event)
+        return if event.self.singleton_class?
+
+        class_name = name_method.bind_call(event.self)
+        return unless callbacks[class_name]
+
+        callback = callbacks.delete(class_name)
+        tracer.disable if callbacks.empty?
+
+        callback.call
+      end
+    end
+  end
+end

data/lib/require_profiler/plugins/http_plugin.rb

@@ -19,7 +19,7 @@ module RequireProfiler
 
         Sniffer::DataItem::Request.include(Module.new do
           def require_path
-            @url ||= "#{method.to_s.upcase}:#{(port == 443) ? "https" : "http"}://#{host}#{query}"
+            @url ||= "http:#{method.to_s.upcase}:#{(port == 443) ? "https" : "http"}://#{host}#{query}"
           end
         end)
 

data/lib/require_profiler/plugins/rails_plugin.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RequireProfiler
+  module Plugins
+    # Track Rails initialization: railtie initializers, to_prepare callbacks, and load hooks
+    class RailsPlugin < Base
+      module InitializerPatch
+        def run(...)
+          RailsPlugin.track(:initializer, name, block) { super }
+        end
+      end
+
+      module ToPreparePatch
+        def to_prepare(*args, &block)
+          return super unless block
+
+          super do |*prepare_args|
+            RailsPlugin.track(:to_prepare, nil, block) do
+              instance_exec(*prepare_args, &block)
+            end
+          end
+        end
+      end
+
+      module LoadHookPatch
+        private
+
+        def execute_hook(name, base, options, block)
+          RailsPlugin.track(:load_hook, name, block) { super }
+        end
+      end
+
+      class << self
+        attr_accessor :reporter
+
+        def track(kind, name, block)
+          path = label(kind, name, block)
+          reporter.handle_event(Reporter::Event.new(type: :start, kind: :rails, path:))
+          start = Time.now
+          yield
+        ensure
+          time = Time.now - start
+          reporter.handle_event(Reporter::Event.new(type: :end, path:, time:))
+        end
+
+        def label(kind, name, block)
+          ["rails:#{kind}", name, block&.source_location&.join(":")].compact.join(":")
+        end
+      end
+
+      def activate!
+        RailsPlugin.reporter = reporter
+
+        Patcher.on_load("Rails::Initializable::Initializer") do
+          ::Rails::Initializable::Initializer.prepend(InitializerPatch)
+        end
+        Patcher.on_load("ActiveSupport::Reloader") do
+          ::ActiveSupport::Reloader.singleton_class.prepend(ToPreparePatch)
+        end
+        Patcher.on_load("ActiveSupport::LazyLoadHooks") do
+          ::ActiveSupport.singleton_class.prepend(LoadHookPatch)
+        end
+      end
+    end
+  end
+end

data/lib/require_profiler/plugins/yaml_plugin.rb

@@ -6,15 +6,15 @@ module RequireProfiler
     class YAMLPlugin < Base
       module Patch
         def load_file(path, ...)
-          YAMLPlugin.track(path) { super }
+          YAMLPlugin.track(path.to_s) { super }
         end
 
         def unsafe_load_file(path, ...)
-          YAMLPlugin.track(path) { super }
+          YAMLPlugin.track(path.to_s) { super }
         end
 
         def safe_load_file(path, ...)
-          YAMLPlugin.track(path) { super }
+          YAMLPlugin.track(path.to_s) { super }
         end
       end
 

data/lib/require_profiler/plugins.rb

@@ -6,6 +6,7 @@ module RequireProfiler
       def register_reporter(reporter)
         HTTPPlugin.new(reporter).activate! unless ENV["REQUIRE_PROFILER_HTTP"] == "false"
         YAMLPlugin.new(reporter).activate! unless ENV["REQUIRE_PROFILER_YAML"] == "false"
+        RailsPlugin.new(reporter).activate! unless ENV["REQUIRE_PROFILER_RAILS"] == "false"
       end
     end
 
@@ -19,5 +20,6 @@ module RequireProfiler
 
     autoload :HTTPPlugin, "require_profiler/plugins/http_plugin"
     autoload :YAMLPlugin, "require_profiler/plugins/yaml_plugin"
+    autoload :RailsPlugin, "require_profiler/plugins/rails_plugin"
   end
 end

data/lib/require_profiler/printer/call_stack.rb

@@ -4,13 +4,22 @@ module RequireProfiler
   module Printer
     # CallStack formatter prints collapsed stacks (Brendan Gregg's format)
     class CallStack < Base
+      # Rails labels are "rails:#{type}:#{detail}", e.g. "rails:initializer:name:file:line"
+      RAILS_LABEL_PARTS = 3
+      RAILS_TYPE_INDEX = 1
+
       def flush(node, parts: [])
         return unless flush?(node)
 
-        path = node.path.sub(prefix_stripper, "")
-        self_parts = (node.kind == :path) ? path.split("/") : [path]
+        path = strip_prefix(node.path)
+        self_parts =
+          case node.kind
+          when :rails then rails_frames(path)
+          when :path then path_frames(path)
+          else [path]
+          end
 
-        parts += self_parts.size.times.map { self_parts.take(_1 + 1).join("/") }
+        parts += self_parts
         # We only show self-time, so exclude children
         val = ((node.time - node.children.sum(&:time)) * 1000).round(3)
 
@@ -18,6 +27,17 @@ module RequireProfiler
 
         node.children.each { flush(_1, parts:) }
       end
+
+      private
+
+      def rails_frames(path)
+        ["rails:#{path.split(":", RAILS_LABEL_PARTS)[RAILS_TYPE_INDEX]}", path]
+      end
+
+      def path_frames(path)
+        segments = path.split("/")
+        segments.size.times.map { segments.take(_1 + 1).join("/") }
+      end
     end
   end
 end

data/lib/require_profiler/printer/text.rb

@@ -8,7 +8,7 @@ module RequireProfiler
       def flush(node, indent: 0)
         return unless flush?(node)
 
-        path = node.path.sub(prefix_stripper, "")
+        path = strip_prefix(node.path)
         output << "#{PAD * indent}#{path} — #{time_to_duration(node.time)}\n"
         node.children.each { flush(_1, indent: indent + 1) }
 

data/lib/require_profiler/printer.rb

@@ -16,7 +16,7 @@ module RequireProfiler
         prefixes << ::Gem.dir if defined?(::Gem.dir)
         prefixes << ::Bundler.bundle_path if defined?(::Bundler.bundle_path)
 
-        @prefix_stripper = %r{^(#{prefixes.join("|")})/}
+        @prefix_stripper = %r{(^|:)(#{prefixes.join("|")})/}
       end
 
       def flush(node)
@@ -29,6 +29,10 @@ module RequireProfiler
 
       private
 
+      def strip_prefix(path)
+        path.sub(prefix_stripper, '\1')
+      end
+
       def flush?(node)
         return false unless (node.time * 1000) >= threshold
 

data/lib/require_profiler/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RequireProfiler # :nodoc:
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/require_profiler.rb

@@ -4,6 +4,7 @@ module RequireProfiler
   autoload :Reporter, "require_profiler/reporter"
   autoload :Printer, "require_profiler/printer"
   autoload :Plugins, "require_profiler/plugins"
+  autoload :Patcher, "require_profiler/patcher"
 
   # Autoload doesn't work here, because we call it from the hooks for the first time
   require "require_profiler/ruby_profiling"

data/skills/rails-boot-profiling/SKILL.md

@@ -0,0 +1,237 @@
+---
+name: rails-boot-profiling
+description: Profile Rails application boot time to find slow requires. Use when the user asks why the app boots slowly, wants to profile boot time, or needs to optimize require/load performance.
+gem: require-profiler
+versions: ">= 0.2"
+---
+
+# Rails Boot Time Profiling
+
+Profile Rails application boot time using the require-profiler gem. This skill helps identify which `require`, `load`, YAML, and HTTP calls dominate startup time, and provides tools to drill deeper into slow files.
+
+## Prerequisites
+
+Before profiling, ensure these conditions are met:
+
+1. The `require-profiler` gem is in the Gemfile (at minimum in the development group).
+
+2. Eager loading must be enabled for the environment you are profiling. Check the environment config:
+
+```ruby
+# config/environments/development.rb (or the target environment)
+config.eager_load = true
+```
+
+If `eager_load` is `false`, the profile will miss most application code — only files loaded during boot are captured, and lazy-loaded files will not appear.
+
+3. Add `-W0` to the Ruby command to suppress warnings and keep output clean.
+
+## Step 1: Run a Full Boot Profile
+
+Run the base profiling command:
+
+```sh
+bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+```
+
+This loads `config/boot.rb` first (to set up Bundler and Bootsnap) and then profiles everything loaded by `config/environment.rb`.
+
+The output is an indented tree showing each required file with its load time (self + children) in milliseconds:
+
+```
+config/environment.rb — 4312.071ms
+  config/application.rb — 3672.445ms
+    railties (>= 0) — 1023.112ms
+      actionpack (>= 0) — 412.331ms
+        actionview (>= 0) — 198.442ms
+    app/models/user.rb — 87.203ms
+    app/models/order.rb — 142.891ms
+      app/models/concerns/auditable.rb — 12.004ms
+  config/initializers/stripe.rb — 523.117ms
+    stripe (>= 0) — 498.201ms
+```
+
+To get a quick count of how many files were loaded:
+
+```sh
+bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb | wc -l
+```
+
+## Step 2: Narrow the Scope
+
+### Filter by Threshold
+
+Exclude files that loaded faster than a given number of milliseconds (supports floats):
+
+```sh
+REQUIRE_PROFILE_THRESHOLD=100 bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+```
+
+This shows only files that took 100ms or more to load — useful for quickly spotting the biggest offenders.
+
+### Filter by Focus Pattern
+
+Show only files matching a pattern (uses `Regexp.new(...)` under the hood):
+
+```sh
+REQUIRE_PROFILE_FOCUS="stripe" bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+```
+
+The focus filter also keeps ancestor nodes in the tree, so you can see the full require chain leading to the matched files.
+
+Combine both for a precise view:
+
+```sh
+REQUIRE_PROFILE_THRESHOLD=50 REQUIRE_PROFILE_FOCUS="initializers" bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+```
+
+## Step 3: Check YAML and HTTP Activity During Boot
+
+By default, require-profiler tracks YAML file loads (`YAML.load_file`, etc.) and adds them to the profile tree. This helps find initializers or gems that parse large YAML configs at boot time.
+
+HTTP request tracking is also available but requires the [sniffer](https://github.com/aderyabin/sniffer) gem to be in the Gemfile. This surfaces any HTTP calls made during boot (e.g., config fetches from remote services, gem activation pings).
+
+To disable either:
+
+```sh
+# Disable YAML tracking
+REQUIRE_PROFILER_YAML=false bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+
+# Disable HTTP tracking
+REQUIRE_PROFILER_HTTP=false bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+
+# Disable all plugins (YAML + HTTP)
+REQUIRE_PROFILER_PLUGINS=false bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+```
+
+## Step 4: Deep-Dive with Stackprof
+
+When you identify a file that is unexpectedly slow to load, use Stackprof to profile what happens inside that file during `require`:
+
+```sh
+REQUIRE_PROFILE_STACKPROF=config/initializers/stripe.rb bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+```
+
+The `stackprof` gem must be in the Gemfile. This generates two files:
+
+- `config-initializers-stripe-stackprof.json` — JSON format, viewable in [Speedscope](https://www.speedscope.app/)
+- `config-initializers-stripe-stackprof.dump` — raw Stackprof data, analyzable with the `stackprof` CLI
+
+To analyze with the stackprof CLI:
+
+```sh
+bundle exec stackprof config-initializers-stripe-stackprof.dump
+bundle exec stackprof config-initializers-stripe-stackprof.dump --method 'ClassName#method_name'
+```
+
+To view in Speedscope, open https://www.speedscope.app/ and drag the `.json` file onto the page (nothing is uploaded — parsing is local).
+
+## Step 5: Export as JSON for Speedscope
+
+Generate a Speedscope-compatible JSON profile of the entire boot:
+
+```sh
+REQUIRE_PROFILE_PATH=tmp/require-profile.json bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+```
+
+This writes a JSON file conforming to the [Speedscope file format schema](https://www.speedscope.app/file-format-schema.json). Open it in Speedscope and use the **Left Heavy** view to find the most expensive require chains, and the **Sandwich** view to find files that appear repeatedly across different chains.
+
+If the Speedscope CLI is installed (`npm install -g speedscope`), open it directly:
+
+```sh
+npx speedscope tmp/require-profile.json
+```
+
+You can also use the `REQUIRE_PROFILE_FORMAT` env var to select the output format explicitly (`text`, `json`, or `call_stack`). When the output path ends in `.json`, the JSON format is selected automatically.
+
+## Collapsed Call Stack Format
+
+For flame graph generation with external tools (e.g., `flamegraph.pl`, `inferno`), use the collapsed call stack format:
+
+```sh
+REQUIRE_PROFILE_FORMAT=call_stack REQUIRE_PROFILE_PATH=tmp/require-profile.txt bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+```
+
+This emits one line per stack in Brendan Gregg's collapsed format with per-frame self time in milliseconds.
+
+## Environment Variable Reference
+
+| Variable | Purpose | Example |
+|---|---|---|
+| `REQUIRE_PROFILE_THRESHOLD` | Minimum load time in ms to include (float) | `100`, `50.5` |
+| `REQUIRE_PROFILE_FOCUS` | Regexp pattern to filter files | `"stripe"`, `"initializers"` |
+| `REQUIRE_PROFILE_PATH` | Output file path (enables file output) | `tmp/require-profile.json` |
+| `REQUIRE_PROFILE_FORMAT` | Output format: `text`, `json`, `call_stack` | `json` |
+| `REQUIRE_PROFILE_STACKPROF` | File path to deep-profile with Stackprof | `config/initializers/stripe.rb` |
+| `REQUIRE_PROFILER_YAML` | Disable YAML tracking when set to `false` | `false` |
+| `REQUIRE_PROFILER_HTTP` | Disable HTTP tracking when set to `false` | `false` |
+| `REQUIRE_PROFILER_PLUGINS` | Disable all plugins when set to `false` | `false` |
+
+## Important: Use the Profiler's Built-in Filtering
+
+**Prefer profiler's built-in filtering and searching capabilities over `grep`, `tail`, `head`, `awk`, or `sed` to filter or search results.**:
+
+- To find slow files → use `REQUIRE_PROFILE_THRESHOLD`, not `grep` for timing patterns
+- To investigate a specific gem or file → use `REQUIRE_PROFILE_FOCUS`, not `grep` for the name
+- To reduce output size → use `REQUIRE_PROFILE_THRESHOLD` + `REQUIRE_PROFILE_FOCUS`, not `tail -N | head -M`
+
+Shell-based filtering breaks the indented tree structure (you lose parent-child relationships), misses context, and requires re-running the full profile each time you change the filter. The built-in env vars preserve the tree, show ancestor chains, and handle edge cases the profiler already knows about.
+
+The only acceptable uses of piping are:
+- `| wc -l` to count total loaded files in step 1
+- Piping into a file when `REQUIRE_PROFILE_PATH` is not available
+
+## Recommended Agent Workflow
+
+Follow this sequence when a user asks about slow boot time:
+
+1. **Get a baseline.** Run the full profile command and note the total boot time (the top-level entry's duration) and total file count (`| wc -l`).
+
+   ```sh
+   bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+   ```
+
+2. **Find the top offenders.** Re-run with `REQUIRE_PROFILE_THRESHOLD` to surface only slow files. Start with a threshold that shows roughly 10-20 entries (e.g., if total boot is ~4s, try 100ms; if ~1s, try 30ms). Report the top slowest entries to the user.
+
+   ```sh
+   REQUIRE_PROFILE_THRESHOLD=100 bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+   ```
+
+3. **Investigate specific areas.** Use `REQUIRE_PROFILE_FOCUS` to zoom into a gem, initializer, or file. The focus pattern is a regexp — use it to match file paths, gem names, or directory patterns. Combine with `REQUIRE_PROFILE_THRESHOLD` for precision.
+
+   ```sh
+   # Investigate a specific gem
+   REQUIRE_PROFILE_FOCUS="stripe" bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+
+   # Investigate all initializers that took > 50ms
+   REQUIRE_PROFILE_THRESHOLD=50 REQUIRE_PROFILE_FOCUS="initializers" bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+   ```
+
+4. **Check for boot-time side effects.** YAML and HTTP entries appear in the profile tree by default. HTTP calls during boot are almost always worth investigating — they add latency and can fail. Use `REQUIRE_PROFILE_FOCUS` to find them:
+
+   ```sh
+   # Find YAML loading
+   REQUIRE_PROFILE_FOCUS="\.yml" bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+
+   # Find HTTP calls during boot
+   REQUIRE_PROFILE_FOCUS="(GET|POST|PATCH|DELETE):" bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+   ```
+
+5. **Deep-dive when needed.** For files that are unexpectedly slow (the load time seems too high for what the file does), use `REQUIRE_PROFILE_STACKPROF` to generate a Stackprof profile and identify what's happening inside that file.
+
+   ```sh
+   REQUIRE_PROFILE_STACKPROF=config/initializers/stripe.rb bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+   ```
+
+6. **Generate a JSON profile for handoff.** If the user wants to explore the data themselves, or if the profile is too large to analyze in text, export to JSON and point them to Speedscope.
+
+   ```sh
+   REQUIRE_PROFILE_PATH=tmp/require-profile.json bundle exec ruby -W0 -r./config/boot -require-prof config/environment.rb
+   ```
+
+7. **Suggest actionable improvements** based on findings:
+   - Move heavy gem requires behind lazy loading or autoload
+   - Defer initializer work to `after_initialize` or `to_prepare` callbacks
+   - Replace boot-time HTTP calls with cached configs or async fetches
+   - Split large YAML files or cache parsed results
+   - Consider using `bootsnap` if not already present

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: require-profiler
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Vladimir Dementyev
@@ -65,6 +65,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '7.2'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -134,8 +148,10 @@ files:
 - lib/equire-prof.rb
 - lib/require-profiler.rb
 - lib/require_profiler.rb
+- lib/require_profiler/patcher.rb
 - lib/require_profiler/plugins.rb
 - lib/require_profiler/plugins/http_plugin.rb
+- lib/require_profiler/plugins/rails_plugin.rb
 - lib/require_profiler/plugins/yaml_plugin.rb
 - lib/require_profiler/printer.rb
 - lib/require_profiler/printer/call_stack.rb
@@ -144,6 +160,7 @@ files:
 - lib/require_profiler/reporter.rb
 - lib/require_profiler/ruby_profiling.rb
 - lib/require_profiler/version.rb
+- skills/rails-boot-profiling/SKILL.md
 homepage: https://github.com/palkan/require-profiler
 licenses:
 - MIT
@@ -153,6 +170,9 @@ metadata:
   documentation_uri: https://github.com/palkan/require-profiler
   homepage_uri: https://github.com/palkan/require-profiler
   source_code_uri: https://github.com/palkan/require-profiler
+  hyperdrive_targets: railties
+  hyperdrive_artifacts: skill
+  hyperdrive_skills_dir: "./skills"
 rdoc_options: []
 require_paths:
 - lib
@@ -167,7 +187,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.16
 specification_version: 4
 summary: 'Profile Ruby #require/#load/etc calls'
 test_files: []