profile-tools 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2ea7a642f74758aef7887554315fac1c6141058a668f9c42bd94cb90db90d0b8
-  data.tar.gz: 1d4f88fa199c5c6adf6162d39b221b41ed4fc9679b9d727e99b3c84950e0a3d4
+  metadata.gz: 4dcb344b200080160f3c9549aef70ccb9714527e4fd9594557f9b7ec3d0f6315
+  data.tar.gz: 70adfdbcfc6ad337a44ea49e6c71d8861f38e40145d78f36f6ad091204e0e1ba
 SHA512:
-  metadata.gz: 95b41c270ca78f611e60863f046d0a0141107bc620e2ca93c726ed806dae98b03c0a9143ed0356de794a8c6d047d151a98529d38e293444d38be4f49a4a5af7a
-  data.tar.gz: 415571c41e649b9548b1e4011245b90a1fd30328c90f5428469d6dea11ee7d00b775e19b8511bb914680187f2fcc8c40f1bad0c61c313bfbcadc65fd700b3ac1
+  metadata.gz: c7d3ed40b95aec0b7b336d3d8dbb127e941a3728f1c618dcc8969def3f0a5bc841492f349e543894afe0ceae6a66a441f3ea1f899a674cbc38b635477f12858a
+  data.tar.gz: 7cdb0b6bfaa65310ba4150dcc07463e93d43095ddcebfcab0d9bd67c60c7e757d5a75d64e8af64ae92c1885a82af5fab1f8256da16868a1f2d16b959fe81da37

data/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+## [0.2.0](https://github.com/dougyouch/profile-tools/compare/v0.1.0...v0.2.0) (2026-10-05)
+
+
+### ⚠ BREAKING CHANGES
+
+* ProfileTools is now a module. Use ProfileTools.profile_method('User#save') and ProfileTools.stop_profiling('User.find', ...) instead of the profile_*/remove_profiled_* instance methods. Per-type count_objects is replaced by an exact allocations total plus gc_count and gc_time, the collector exposes stats (MethodStats objects) instead of methods (hashes), and the log format changed. See UPGRADING.md.
+* **gem:** Ruby 3.4 or newer and ActiveSupport 7.1 or newer are now required. Ruby 3.4 is the first version where forwarding arguments with ... allocates nothing, which exact allocation counts depend on.
+
+### Features
+
+* count allocations exactly and profile from a yaml file with no code changes ([d9a2fb3](https://github.com/dougyouch/profile-tools/commit/d9a2fb3acc3cd487c0004b60ad526ca220076983))
+
+
+### Build System
+
+* **gem:** require ruby 3.4 and activesupport 7.1 ([2347ecf](https://github.com/dougyouch/profile-tools/commit/2347ecfea681cde5ca70ddf440015acb5090dcfb))
+
+## 0.1.0 (2019-08-30)
+
+* Initial release: profile methods listed in a YAML file, logging call counts, time and object counts per method

data/README.md

@@ -1,2 +1,207 @@
-# profile-tools
-Ruby profiling tools
+# ProfileTools
+
+Find the code that allocates the most objects and triggers the most garbage collection, in production, without changing that code.
+
+List the methods you suspect in a YAML file and restart. Every request then logs, for each listed method, how many times it was called, how long it took, how many objects it allocated and how many garbage collections ran inside it. Remove the file and restart to turn it off.
+
+[![CI](https://github.com/dougyouch/profile-tools/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/dougyouch/profile-tools/actions/workflows/ci.yml)
+[![Coverage](https://raw.githubusercontent.com/dougyouch/profile-tools/badges/coverage.svg)](https://github.com/dougyouch/profile-tools/actions/workflows/ci.yml)
+[![Branch Coverage](https://raw.githubusercontent.com/dougyouch/profile-tools/badges/branches.svg)](https://github.com/dougyouch/profile-tools/actions/workflows/ci.yml)
+
+[API reference](https://rubydoc.info/gems/profile-tools) · [Upgrading from 0.1](UPGRADING.md) · [Changelog](CHANGELOG.md) · [Architecture](ARCHITECTURE.md)
+
+```
+[ProfileTools] GET /orders/42: 1 call, 0.507ms, 4874 allocations, 0 GC runs (0ms)
+[ProfileTools] Order.find: 1 call, 0.025ms, 401 allocations, 0 GC runs (0ms)
+[ProfileTools] Order#total: 3 calls, 0.474ms, 4473 allocations, 0 GC runs (0ms)
+[ProfileTools] Order#line_items: 3 calls, 0.394ms, 4473 allocations, 0 GC runs (0ms)
+```
+
+Here `Order#total` allocates nothing itself; all 4473 objects come from `Order#line_items`, called once per `total`.
+
+## Installation
+
+Requires Ruby 3.4 or newer and ActiveSupport 7.1 or newer. Add this line to your application's Gemfile:
+
+```ruby
+gem 'profile-tools'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+## Usage with Rails
+
+Nothing else to set up. With the gem installed, profiling is off until a config file exists.
+
+1. Create `config/profile_tools.yml` listing the methods to profile. Keys are class names; values are method names. Class methods start with a dot.
+
+   ```yaml
+   Order:
+     - total
+     - line_items
+     - .find
+   Admin::ReportBuilder:
+     - build
+   ```
+
+   To keep the file out of the app directory, put it anywhere and set `PROFILE_TOOLS_CONFIG=/path/to/profile_tools.yml`.
+
+2. Restart the app server. When the file exists, the gem's Railtie:
+   - wraps the listed methods once the app has booted (after eager loading)
+   - adds `ProfileTools::Middleware`, so each request is reported together under a `GET /path` line
+   - logs the report to `Rails.logger` at info level, tagged like the rest of the request's lines
+
+3. Read the log, then delete the file and restart again.
+
+A typo in the file (a class or method that doesn't exist) raises at boot, so check the app starts before leaving it.
+
+Background jobs (Sidekiq, Active Job) don't go through the middleware; see [Background jobs](#background-jobs) to get one report per job.
+
+## Usage without Rails
+
+Outside Rails, nothing happens automatically: you choose the methods, where reports go, and what counts as one run. It takes three steps.
+
+```ruby
+require 'logger'
+require 'profile-tools'
+
+# 1. Send reports somewhere. Attach first: that loads ActiveSupport::LogSubscriber.
+ProfileTools::LogSubscriber.attach_to :profile_tools
+ActiveSupport::LogSubscriber.logger = Logger.new($stdout)
+
+# 2. Choose the methods, after the classes are loaded
+ProfileTools.load('profile_tools.yml')            # the same YAML format as in Rails, or:
+ProfileTools.profile('Order' => %w[total .find])  # a hash in that shape, or:
+ProfileTools.profile_method('Order#total')        # one method at a time
+
+# 3. Decide what one report covers
+ProfileTools.instrument('nightly import') { Importer.run }
+```
+
+Without an enclosing `instrument` block (or the middleware below), each outermost call to a profiled method is reported on its own.
+
+### Rack apps (Sinatra, Roda, Hanami, plain Rack)
+
+`ProfileTools::Middleware` makes each request one report, named `GET /path`. To keep the drop-in-file workflow, guard the setup in `config.ru` so it only runs when the file is there:
+
+```ruby
+# config.ru
+require_relative 'app'
+
+profile_config = ENV.fetch('PROFILE_TOOLS_CONFIG', 'config/profile_tools.yml')
+if File.exist?(profile_config)
+  require 'logger'
+  require 'profile-tools'
+  ProfileTools::LogSubscriber.attach_to :profile_tools
+  ActiveSupport::LogSubscriber.logger = Logger.new($stdout)
+  ProfileTools.load(profile_config)
+  use ProfileTools::Middleware
+end
+
+run App
+```
+
+### Background jobs
+
+Jobs don't pass through the Rack middleware, in Rails or anywhere else. Wrap each job in `instrument` to get one report per job. With Sidekiq:
+
+```ruby
+class ProfileToolsSidekiqMiddleware
+  include Sidekiq::ServerMiddleware
+
+  def call(_job_instance, job, _queue, &)
+    ProfileTools.instrument(job['class'], &)
+  end
+end
+
+Sidekiq.configure_server do |config|
+  config.server_middleware { |chain| chain.add ProfileToolsSidekiqMiddleware }
+end
+```
+
+### Scripts and the console
+
+```ruby
+ProfileTools.profile_method('Order#total')
+ProfileTools.instrument('check') { Order.find(42).total }
+ProfileTools.profiler.collector.called_methods.map(&:to_h)
+# => [{method: "check", calls: 1, duration: 0.51, allocations: 4874, gc_count: 0, gc_time: 0}, ...]
+```
+
+`script/console` in this repo starts IRB with logging to stdout already set up.
+
+### Sending the numbers somewhere else
+
+Every finished run publishes a `profile.profile_tools` ActiveSupport notification. Subscribe to it instead of (or as well as) attaching the log subscriber:
+
+```ruby
+ActiveSupport::Notifications.subscribe('profile.profile_tools') do |event|
+  event.payload[:collector].called_methods.each do |stats|
+    StatsD.distribution('profile_tools.allocations', stats.allocations, tags: ["method:#{stats.method}"])
+  end
+end
+```
+
+### Stopping
+
+```ruby
+ProfileTools.stop_profiling('Order#total', 'Order.find')
+ProfileTools.stop_profiling!   # every method
+```
+
+## Reading the numbers
+
+Each line covers one method for one request (or `instrument` block):
+
+| Field | Meaning |
+|---|---|
+| calls | Times the method was called |
+| ms | Total time inside the method, including everything it called |
+| allocations | Objects allocated inside the method, including everything it called |
+| GC runs (ms) | Garbage collections that ran inside the method, and the time they took |
+
+The top line (the request or `instrument` block) is the total for the whole request, so you can see what share of it each method accounts for.
+
+### How accurate it is
+
+- **Allocations are exact.** They come from `GC.stat(:total_allocated_objects)`, a counter that only goes up, so garbage collection running mid-call doesn't distort them. The wrapper itself allocates nothing per call, so wrapping a method doesn't add to its caller's count.
+- **Other threads count too.** The counter is process-wide. On a multi-threaded server (Puma with `threads 5, 5`), allocations from other requests running at the same time land in the numbers. For clean numbers, run the profiled box with one thread per process.
+- **The first call can be higher.** Ruby fills method caches on the first call, which allocates. Look at steady-state requests, not the first one after boot.
+- **Recursion is counted once.** A recursive call adds to `calls`, but only the outermost call is measured, so time and allocations aren't double-counted.
+- **Methods with unusual names** (defined with `define_method` and a name that `def` can't write, like `:'my-method'`) fall back to a wrapper that allocates a few objects per call.
+
+### Choosing methods to list
+
+Start broad and narrow down. List a few high-level methods (a service object's `call`, a serializer's `as_json`), find the one with the most allocations, then list the methods it calls. To find candidates first, a sampling profiler like [stackprof](https://github.com/tmm1/stackprof) (`mode: :object`) or [vernier](https://github.com/jhawthorn/vernier) is a good start. ProfileTools then gives you exact numbers for the methods they point at, on real production traffic.
+
+## How it works
+
+`ProfileTools.profile_method('Order#total')` prepends a module to `Order` that defines:
+
+```ruby
+def total(...)
+  ::ProfileTools.profiler.instrument("Order#total".freeze) { super(...) }
+end
+```
+
+`...` passes positional, keyword and block arguments through unchanged, and the method keeps its visibility (public, protected or private). Removing the wrapper deletes that method from the module, and calls go straight to the original again. See [ARCHITECTURE.md](ARCHITECTURE.md) for more.
+
+## Development
+
+```bash
+bundle install
+bundle exec rspec          # specs, with line and branch coverage
+bundle exec rubocop        # lint
+bundle exec yard stats --list-undoc
+script/console             # IRB with the gem loaded and logging to stdout
+```
+
+CI runs RuboCop, a YARD docs check and the specs on Ruby 3.4 and the `.ruby-version` Ruby, and requires 100% line and branch coverage. Releases are automated with release-please from [conventional commits](https://www.conventionalcommits.org/).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

data/UPGRADING.md

@@ -0,0 +1,98 @@
+# Upgrading from 0.1 to 0.2
+
+0.2 is a rewrite of the internals. The YAML file format is unchanged, but most of the Ruby API and all of the reported numbers changed. If you only used `ProfileTools.load` with a YAML file, the main changes are in [Setup](#setup) and [Reported stats](#reported-stats).
+
+## Requirements
+
+| | 0.1 | 0.2 |
+|---|---|---|
+| Ruby | any | 3.4 or newer |
+| ActiveSupport | not declared, but required at runtime | `>= 7.1`, declared |
+| concurrent-ruby | required at runtime, not declared | not used |
+
+Ruby 3.4 is the minimum because it is the first version where forwarding arguments with `...` allocates nothing. On Ruby 3.3, every call to a profiled method would add 1 or 2 objects to the counts.
+
+## Setup
+
+In a Rails app, delete the initializer you used to load the YAML file and attach the log subscriber, then move the file to `config/profile_tools.yml` (or point `PROFILE_TOOLS_CONFIG` at it). The gem's Railtie now loads the file after boot, attaches the log subscriber and adds a middleware that reports each request together. See [Usage with Rails](README.md#usage-with-rails).
+
+Outside Rails, the setup is the same as before, plus `ProfileTools::Middleware` if you want one report per request.
+
+## API changes
+
+`ProfileTools` is now a module, not a class, so `ProfileTools.new` is gone. Methods are named the same way everywhere: `"Class#method"` for instance methods and `"Class.method"` for class methods.
+
+| 0.1 | 0.2 |
+|---|---|
+| `ProfileTools.new.profile_instance_method(:User, :save)` | `ProfileTools.profile_method('User#save')` |
+| `ProfileTools.new.profile_class_method(:User, :find)` | `ProfileTools.profile_method('User.find')` |
+| `ProfileTools.new.remove_profiled_instance_method(:User, :save)` | `ProfileTools.stop_profiling('User#save')` |
+| `ProfileTools.new.remove_profiled_class_method(:User, :find)` | `ProfileTools.stop_profiling('User.find')` |
+| `ProfileTools.stop_profiling(['User#save', 'User.find'])` | `ProfileTools.stop_profiling('User#save', 'User.find')` (takes names, not an array) |
+| `ProfileTools.add_method` / `ProfileTools.delete_method` | removed; use `profile_method` / `stop_profiling` |
+| `ProfileTools.load(path)` / `ProfileTools.profile(hash)` | unchanged |
+| `ProfileTools.stop_profiling!` | unchanged |
+| `ProfileTools.instrument { }` | unchanged, and takes an optional name: `ProfileTools.instrument('import') { }` |
+| | new: `ProfileTools.profiled?('User#save')` |
+
+The default name for an `instrument` block changed from `ProfileTools::Profiler#instrument` to `ProfileTools.instrument`.
+
+`ProfileTools.profiled_methods` still returns the names, but the array is now frozen.
+
+## Reported stats
+
+Per-type object counts are replaced by a single exact allocation count, plus garbage collection numbers.
+
+| 0.1 | 0.2 |
+|---|---|
+| `count_objects` (hash of `T_STRING`, `T_HASH`, ... live-object deltas) | `allocations` (total objects allocated) |
+| `num_collection_calls` | removed |
+| | new: `gc_count` and `gc_time` (ms) |
+| `duration` (ms) | unchanged |
+| `calls` | unchanged |
+
+The old counts came from `ObjectSpace.count_objects`, which counts live objects. They went wrong (sometimes negative) whenever garbage collection ran during a call, and needed hand-tuned corrections. The new count comes from `GC.stat(:total_allocated_objects)` and is exact. If you need a breakdown by type for one method, use [memory_profiler](https://github.com/SamSaffron/memory_profiler) on it once ProfileTools has pointed you at it.
+
+### Log format
+
+```
+# 0.1
+method User#save took 12.34567ms, called 2, objects: T_STRING: 40, T_HASH: 3
+# 0.2
+[ProfileTools] User#save: 2 calls, 12.346ms, 43 allocations, 0 GC runs (0ms)
+```
+
+Update any log searches or alerts that matched the old format.
+
+### Collector
+
+If you read the collector directly (for example in your own notification subscriber):
+
+| 0.1 | 0.2 |
+|---|---|
+| `collector.methods` (hash of hashes) | `collector.stats` (hash of `ProfileTools::MethodStats`) |
+| `collector.called_methods` returned hashes | returns `MethodStats` objects; call `to_h` for a hash |
+| `collector.init_method(name)` | `ProfileTools::Collector.new(names)` |
+| `collector.total_collection_calls` | removed |
+
+The `profile.profile_tools` notification payload now also carries `:name`, the name of the request or `instrument` block.
+
+## Behavior changes
+
+These were bugs in 0.1 and are fixed in 0.2:
+
+- **Blocks and keyword arguments are passed through.** The 0.1 wrapper only forwarded positional arguments, so profiling a method that takes a block or keyword arguments broke it.
+- **An exception no longer turns profiling off.** In 0.1, an exception raised inside a profiled method left the thread's profiler stuck mid-run, and that thread never reported again until restart.
+- **Private and protected methods stay private and protected.** 0.1 made them public.
+- **Setters and operators can be profiled** (`name=`, `[]`, `<=>`). In 0.1 they raised a `SyntaxError`.
+- **Profiling a method twice does nothing.** In 0.1 it caused infinite recursion.
+- **Stopping a method that isn't profiled does nothing.** In 0.1 it raised `NameError`.
+- **A method first seen mid-run, or a nested `instrument` call, no longer raises `NoMethodError`.**
+- **Recursive methods are measured once**, at the outermost call, instead of adding up the nested calls.
+- **Methods are wrapped with `Module#prepend`.** The `*_with_profiling` and `*_without_profiling` aliases are gone, so wrapping no longer conflicts with other code that aliases the same method.
+
+## Errors
+
+- `ProfileTools::Error` is raised for a name that isn't `Class#method` or `Class.method`, and for a YAML file that isn't a mapping of class names to methods.
+- `ProfileTools::UnknownMethodError` (a subclass of `Error`) is raised for a method the class doesn't define.
+- An unknown class still raises `NameError`.

data/lib/profile-tools.rb

@@ -1,135 +1,125 @@
 # frozen_string_literal: true
 
-# ProfileTools is used to instrument specific methods.  Provides feedback about method execution
-#  time and number of objects created.
-class ProfileTools
+require 'active_support/lazy_load_hooks'
+
+# Profiles chosen methods without changing their code: call counts, time, objects allocated
+# and garbage collection, per method and per request.
+#
+#   ProfileTools.profile('User' => ['save', '.find'])
+#   ProfileTools.instrument('nightly import') { Importer.run }
+#
+# In a Rails app, list the methods in config/profile_tools.yml and restart; see {Railtie}.
+module ProfileTools
   autoload :Collector, 'profile_tools/collector'
+  autoload :Error, 'profile_tools/error'
   autoload :LogSubscriber, 'profile_tools/log_subscriber'
+  autoload :MethodName, 'profile_tools/method_name'
+  autoload :MethodStats, 'profile_tools/method_stats'
+  autoload :MethodWrapper, 'profile_tools/method_wrapper'
+  autoload :Middleware, 'profile_tools/middleware'
   autoload :Profiler, 'profile_tools/profiler'
+  autoload :UnknownMethodError, 'profile_tools/unknown_method_error'
+  autoload :VERSION, 'profile_tools/version'
 
+  # ActiveSupport notification published when a profiling run finishes
   EVENT = 'profile.profile_tools'
 
-  @profiled_methods = []
+  # Replaced, never changed in place, so a run that has already read it isn't affected.
+  @profiled_methods = [].freeze
+
   class << self
+    # @return [Array<String>] the profiled methods, such as ["User#save", "User.find"]
     attr_reader :profiled_methods
-  end
-
-  def self.add_method(display_name)
-    profiled_methods << display_name
-  end
-
-  def self.delete_method(display_name)
-    profiled_methods.delete_if { |method| method == display_name }
-  end
 
-  def initialize
-    ObjectSpace.count_objects
-  end
-
-  def profile_instance_method(class_name, method_name)
-    profile_method(Object.const_get(class_name), method_name, "#{class_name}##{method_name}")
-  end
-
-  def profile_class_method(class_name, method_name)
-    profile_method(Object.const_get(class_name).singleton_class, method_name, "#{class_name}.#{method_name}")
-  end
-
-  def remove_profiled_instance_method(class_name, method_name)
-    remove_profiling(Object.const_get(class_name), method_name, "#{class_name}##{method_name}")
-  end
-
-  def remove_profiled_class_method(class_name, method_name)
-    remove_profiling(Object.const_get(class_name).singleton_class, method_name, "#{class_name}.#{method_name}")
-  end
-
-  def self.load(yaml_file)
-    require 'yaml'
-    profile(YAML.load_file(yaml_file))
-  end
-
-  def self.profile(classes)
-    profile_tools = new
+    # Profiles the methods listed in a YAML file: class names as keys, each with a list of
+    # method names. Class methods start with a dot.
+    #
+    #   User:
+    #     - save
+    #     - .find
+    #
+    # @param path [String, Pathname]
+    # @return [void]
+    # @raise [Error] if the file isn't a mapping of class names to method names
+    def load(path)
+      require 'yaml'
+      config = YAML.safe_load_file(path)
+      raise Error, "#{path} must map class names to lists of methods" unless config.is_a?(Hash)
+
+      profile(config)
+    end
 
-    classes.each do |class_name, methods|
-      methods.each do |method_name|
-        if method_name =~ /\A\./
-          profile_tools.profile_class_method(class_name, method_name[1, method_name.size])
-        else
-          profile_tools.profile_instance_method(class_name, method_name)
-        end
+    # Profiles the methods in a hash shaped like the YAML file in {.load}.
+    #
+    # @param config [Hash{String => Array<String>, String}] class name => method names (".name" for class methods)
+    # @return [void]
+    def profile(config)
+      config.each do |class_name, methods|
+        Array(methods).each { |method| profile_method(full_method_name(class_name, method)) }
       end
     end
 
-    profile_tools
-  end
-
-  def self.stop_profiling(methods)
-    profile_tools = new
+    # Starts profiling a method. Profiling one that already is does nothing.
+    #
+    # @param name [String] "Class#method" or "Class.method"
+    # @return [void]
+    # @raise [Error] if the name isn't in either form
+    # @raise [NameError] if the class doesn't exist
+    # @raise [UnknownMethodError] if the class doesn't define the method
+    def profile_method(name)
+      method_name = MethodName.new(name)
+      return if profiled?(method_name.name)
+
+      MethodWrapper.new(method_name).wrap
+      @profiled_methods = [*@profiled_methods, method_name.name].freeze
+    end
 
-    methods.each do |method|
-      if method =~ /#/
-        profile_tools.remove_profiled_instance_method(*method.split('#', 2))
-      elsif method =~ /\./
-        profile_tools.remove_profiled_class_method(*method.split('.', 2))
+    # Stops profiling the given methods. Names that aren't profiled are ignored.
+    #
+    # @param names [Array<String>] "Class#method" or "Class.method"
+    # @return [void]
+    def stop_profiling(*names)
+      names.map(&:to_s).select { |name| profiled?(name) }.each do |name|
+        MethodWrapper.new(MethodName.new(name)).unwrap
+        @profiled_methods = (@profiled_methods - [name]).freeze
       end
     end
-  end
-
-  def self.stop_profiling!
-    stop_profiling(profiled_methods.dup)
-  end
 
-  def self.profiler
-    Thread.current[:profile_tools_profiler] ||= Profiler.new
-  end
+    # Stops profiling every method.
+    #
+    # @return [void]
+    def stop_profiling!
+      stop_profiling(*profiled_methods)
+    end
 
-  def self.instrument
-    profiler.instrument do
-      yield
+    # @param name [String] "Class#method" or "Class.method"
+    # @return [Boolean] true if the method is being profiled
+    def profiled?(name)
+      profiled_methods.include?(name.to_s)
     end
-  end
 
-  private
+    # @return [Profiler] the current thread's profiler
+    def profiler
+      Thread.current[:profile_tools_profiler] ||= Profiler.new
+    end
 
-  def profile_method(kls, method_name, display_name)
-    self.class.add_method(display_name)
+    # Measures the block under the given name. Profiled methods it calls are reported with it.
+    #
+    # @param name [String] name to report the block under
+    # @yield the code to measure
+    # @return [Object] the block's result
+    def instrument(name = Profiler::DEFAULT_NAME, &)
+      profiler.instrument(name, &)
+    end
 
-    method_name_without_profiling = generate_method_name(method_name.to_s, 'without_profiling')
-    method_name_with_profiling = generate_method_name(method_name.to_s, 'with_profiling')
+    private
 
-    kls.class_eval(
-<<-STR, __FILE__, __LINE__ + 1
-def #{method_name_with_profiling}(*args)
-  ::ProfileTools.profiler.instrument('#{display_name}') do
-    #{method_name_without_profiling}(*args)
+    def full_method_name(class_name, method)
+      method = method.to_s
+      method.start_with?('.') ? "#{class_name}#{method}" : "#{class_name}##{method}"
+    end
   end
 end
-STR
-    )
 
-    kls.alias_method(method_name_without_profiling, method_name)
-    kls.alias_method(method_name, method_name_with_profiling)
-  end
-
-  def generate_method_name(method_name, suffix)
-    punctuation =
-      if method_name =~ /(\?|!)$/
-        $1
-      end
-
-    method_name = method_name.sub(punctuation, '') if punctuation
-
-    "#{method_name}_#{suffix}#{punctuation}"
-  end
-
-  def remove_profiling(kls, method_name, display_name)
-    self.class.delete_method(display_name)
-
-    method_name_without_profiling = generate_method_name(method_name.to_s, 'without_profiling')
-    method_name_with_profiling = generate_method_name(method_name.to_s, 'with_profiling')
-
-    kls.alias_method(method_name, method_name_without_profiling)
-    kls.send(:remove_method, method_name_with_profiling)
-    kls.send(:remove_method, method_name_without_profiling)
-  end
-end
+# Runs when a Rails app class is defined, early enough for the Railtie's initializers to run
+ActiveSupport.on_load(:before_configuration) { require 'profile_tools/railtie' }