runtime_profiler 0.3.0 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7839cd9d608c73c35a269e4bf7f2f52ae482e714dd99a108e9078e6628f9a86b
-  data.tar.gz: 9eecf865436dcd07b575d96c1bfb21d1ba1c9344c9100aa955ed00a84d2e8011
+  metadata.gz: c65d8e5bf6fc5d9c3a429de889693927953c5194ae5a3562c76f2eed92f5ab09
+  data.tar.gz: 3067f05a450557a11c1a8c44d0573fae93fdef06b7daecde1b7c1ed1a6bfd6be
 SHA512:
-  metadata.gz: eaeedf57a5c02b27e1f75778290f821a4b0ed3901220c7dce8529df44d4bf49fe8d0846a4bb3e7e73b485c96196f85d7d57a6cc3e8df93bfda8b05676526ddc1
-  data.tar.gz: 196e71a0244d7d47c8af6585213c45373dcc8d694bac70daa86e9688877d4b02fc029bc50df87baf3ce288e64c8c7850ea717603975eb38a9da367e34998d9a5
+  metadata.gz: 6712090d8b730c59d6250a12391962233b759dfeca38713b7cfe5bb6d714d6e99e38bef7b47262c30720b68f543b34e227d6e8cee73d1076fe68aba476755d3b
+  data.tar.gz: 454623783d6444cac238637b86f45e741479eeb1295f5ac246a003ac91a5b8f7b7be8a614fff1123f7c7c3e54bf077df8f5787173bcda1f7aac984fd74627ce8

data/README.md

@@ -1,16 +1,36 @@
-# runtime_profiler - Runtime Profiler for Rails Applications [![Build Status](https://wnuqui.semaphoreci.com/badges/runtime_profiler/branches/master.svg?style=shields)](https://wnuqui.semaphoreci.com/projects/runtime_profiler)
+# runtime_profiler
 
-`runtime_profiler` instruments API endpoints or methods in your Rails application using Rails' `ActiveSupport::Notifications`. Currently, it is intended to be used during development or test.
+*A runtime profiler for Rails applications.*
 
-It then aggregates and generates report to give you insights about specific calls in your Rails application.
+Check which part of your Rails application is causing slow response time. **runtime_profiler** gives you an easy way to find performance problems by profiling an endpoint or a method in your Rails application.
 
-## Installation
+[![Build Status](https://wnuqui.semaphoreci.com/badges/runtime_profiler/branches/master.svg?style=shields)](https://wnuqui.semaphoreci.com/projects/runtime_profiler)
+
+## Table of contents
+
+- [Getting Started](#getting-started)
+  - [Installing](#installing)
+  - [Profiling](#profiling)
+    - [Structure](#structure)
+    - [Examples](#examples)
+  - [Viewing Profiling Result](#viewing-profiling-result)
+    - [view Options](#view-options)
+  - [Screenshot](#screenshot)
+  - [Configurations](#configurations)
+- [Development](#development)
+- [Contributing](#contributing)
+- [Acknowledgement](#acknowledgement)
+- [License](#license)
+
+## Getting Started
+
+### Installing
 
 Add this line to your application's Gemfile:
 
 ```ruby
+# In your Gemfile
 group :development, :test do
-  ... ...
   gem 'runtime_profiler'
 end
 ```
@@ -19,13 +39,33 @@ And then execute:
 
     $ bundle
 
-## Profiling/Instrumenting
+Or install it yourself as:
+
+    $ gem install runtime_profiler
+
+### Profiling
+
+#### Structure
+
+To profile a specific class (model, controller, etc), all you need to do is to wrap a line where the target class (or instance) is calling a method (entry point of profiling).
 
-To start profiling, you can make a test that targets a particular endpoint and use `RuntimeProfiler.profile!` method in the test. The output of instrumentation will be generated under the `tmp` folder of your application.
+```ruby
+# Profiles runtime of `ClassToProfile` class.
+RuntimeProfiler.profile!('description', [ClassToProfile]) {
+  # one line where `ClassToProfile` (or its instance) is calling a method
+}
+```
+
+Since the second argument of `.profile!` accepts array of classes, then you can provide all target classes that you want to profile.
+
+#### Examples
+
+You can make a test that targets a particular endpoint (or even just a method) and use `RuntimeProfiler.profile!` method in the test.
 
-Example of a test code wrap by `RuntimeProfiler.profile!` method:
 ```ruby
 it 'updates user' do
+  # Profiles runtime of PUT /users/:id endpoint and
+  # specifically interested with the methods of `User` model.
   RuntimeProfiler.profile!('updates user', [User]) {
     patch :update, { id: user.id, name: 'Joe' }
   }
@@ -36,25 +76,26 @@ end
 
 Run the test as usual and follow printed instructions after running.
 
-If you prefer writing just code snippet, then just wrap the snippet with `RuntimeProfiler.profile!` method:
+Or if you prefer writing just code snippet, then just wrap the snippet with `RuntimeProfiler.profile!` method:
 ```ruby
+# Profiles runtime of `UserMailer` mailer.
 RuntimeProfiler.profile!('UserMailer', [UserMailer]) {
   user = User.last
   UserMailer.with(user: user).weekly_summary.deliver_now
 }
 ```
 
-**Note:** The code (tests or not) where `RuntimeProfiler.profile!` is used must be **free from any mocking** since your goal is to check bottlenecks.
+**Note:** The code (test or not) where `RuntimeProfiler.profile!` is used must be **free from any mocking/stubbing** since the goal is to check performance bottlenecks.
 
-## Viewing Profiling Result
+### Viewing Profiling Result
 
-To see profiling/instrumenting report, you can open the report in browser with JSON viewer report. Or you can run the following command:
+To see profiling report, you can open the report in browser with JSON viewer report. Or you can run the following command:
 
 ```bash
-bundle exec runtime_profiler view ~/the-rails-app/tmp/runtime-profiling-51079-1521371428.json
+bundle exec runtime_profiler view tmp/rp-124094-1608308786.json
 ```
 
-### view options
+#### view options
 
 Here are the command line options for `runtime_profiler view` command.
 
@@ -97,14 +138,22 @@ $ bundle exec runtime_profiler view --help
         ROUNDING is integer value. Used in rounding runtimes. Default is 4.
 ```
 
-## Configurations
+### Screenshot
+
+<p align="center">
+  <img src="rp_view_command.png">
+</p>
+
+### Configurations
 
-All the configurable variables and their defaults are listed below. These configurations can be put in the `config/initializers` folder of your Rails application.
+All the configurable variables and their defaults are listed below. There is no one correct place where to put these configurations. It can be inside `config/initializers` folder of your Rails application. Or if you are using test to profile, it can be in the last part of `spec/spec_helper.rb`.
 ```ruby
 RuntimeProfiler.output_path = File.join(Rails.root.to_s, 'tmp')
-RuntimeProfiler.instrumented_constants = [User]
-RuntimeProfiler.instrumented_paths = %w(app lib)
-RuntimeProfiler.instrumented_sql_commands = %w(SELECT INSERT UPDATE DELETE)
+RuntimeProfiler.profiled_constants = [User]
+RuntimeProfiler.profiled_paths = %w(app lib)
+RuntimeProfiler.profiled_sql_commands = %w(SELECT INSERT UPDATE DELETE)
+# Useful when you want to exclude in profiling specific method(s) from framework/library being used
+RuntimeProfiler.excepted_methods = [:attribute_type_decorations, :_validators, :defined_enums]
 ```
 
 ## Development

data/lib/runtime_profiler.rb

@@ -1,45 +1,48 @@
 require 'active_support'
 
 require 'runtime_profiler/profiler'
-require 'method_meter'
 
 module RuntimeProfiler
   include ActiveSupport::Configurable
 
-  config_accessor :instrumented_constants do
+  config_accessor :profiled_constants do
     []
   end
 
-  config_accessor :instrumented_paths do
-    %w(app lib)
+  config_accessor :profiled_paths do
+    %w[app lib]
   end
 
-  config_accessor :instrumented_sql_commands do
-    %w(SELECT INSERT UPDATE DELETE)
+  config_accessor :profiled_sql_commands do
+    %w[SELECT INSERT UPDATE DELETE]
   end
 
   config_accessor :output_path do
-    if defined?(Rails) && Rails.respond_to?(:root)
+    if defined?(Rails) && Rails.respond_to?(:root) && Rails.root
       File.join(Rails.root.to_s, 'tmp')
     else
       'tmp'
     end
   end
 
+  config_accessor :excepted_methods do
+    []
+  end
+
   class << self
     def configure
-      Rails.application.eager_load! rescue nil
+      begin
+        Rails.application.eager_load!
+      rescue StandardError
+        nil
+      end
       yield self if block_given?
     end
 
-    def profile!(key, konstants)
-      konstants = konstants.is_a?(Array) ? konstants : [konstants]
-      profiler = Profiler.new(konstants)
-      profiler.prepare_for_instrumentation
-
-      MethodMeter.measure!(key) { yield }
-
-      profiler.save_instrumentation_data
+    def profile!(key, constants)
+      constants = constants.is_a?(Array) ? constants : [constants]
+      profiler = Profiler.new(constants)
+      profiler.profile!(key) { yield }
     end
   end
-end
+end

data/lib/runtime_profiler/callbacks/action_controller.rb

@@ -12,6 +12,7 @@ module RuntimeProfiler
       def call(*args)
         event = RuntimeProfiler::ProcessActionEvent.new(args: args)
         return unless event.recordable?
+
         add event
       end
 

data/lib/runtime_profiler/callbacks/active_record.rb

@@ -26,12 +26,12 @@ module RuntimeProfiler
 
         @data[key][:sql]      = event.sanitized_sql
         @data[key][:runtimes] = [
-          [ event.total_runtime, event.trace.first ]
+          [event.total_runtime, event.trace.first]
         ]
       end
 
       def update(event)
-        @data[event.key][:runtimes] << [ event.total_runtime, event.trace.first ]
+        @data[event.key][:runtimes] << [event.total_runtime, event.trace.first]
       end
     end
   end

data/lib/runtime_profiler/cli.rb

@@ -49,4 +49,4 @@ module RuntimeProfiler
       run!
     end
   end
-end
+end

data/lib/runtime_profiler/{instrumentation_data.rb → data.rb}

@@ -1,5 +1,5 @@
 module RuntimeProfiler
-  class InstrumentationData
+  class Data
     attr_reader :controller_data, :sql_data
 
     def initialize(controller_data: nil, sql_data: nil)
@@ -8,14 +8,36 @@ module RuntimeProfiler
     end
 
     def persist!
-      instrumented_api = [
+      File.open(output_file, 'w') do |f|
+        f.write JSON.dump(profiling_data)
+      end
+
+      puts "\n"
+      puts 'Profiling data written at ' + output_file.to_s
+      puts 'You can view profiling data via: bundle exec runtime_profiler view ' + output_file.to_s
+      puts "\n"
+    end
+
+    private
+
+    def output_file
+      FileUtils.mkdir_p(RuntimeProfiler.output_path)
+      filename = ['rp', Process.pid, Time.now.to_i].join('-') + '.json'
+      File.join(RuntimeProfiler.output_path, filename)
+    end
+
+    def profiled_api
+      return unless controller_data[:payload]
+      @profiled_api ||= [
         controller_data[:payload][:controller],
         controller_data[:payload][:action]
-      ].join('#') if controller_data[:payload]
+      ].join('#')
+    end
 
-      instrumentation_data = {
-        instrumentation: {
-          instrumented_api: instrumented_api,
+    def profiling_data
+      @profiling_data ||= {
+        profiling: {
+          profiled_api: profiled_api,
           summary: {
                         db_runtime: controller_data[:db_runtime],
                       view_runtime: controller_data[:view_runtime],
@@ -27,59 +49,34 @@ module RuntimeProfiler
                     slowest_method: method_calls_data[:slowest_method],
               mostly_called_method: method_calls_data[:mostly_called_method]
           },
-          instrumented_sql_calls: sql_calls_data[:instrumented_sql_calls],
-          instrumented_methods: method_calls_data[:instrumented_methods],
-          instrumented_at: Time.now
+          profiled_sql_calls: sql_calls_data[:profiled_sql_calls],
+          profiled_methods: method_calls_data[:profiled_methods],
+          profiled_at: Time.now
         }
       }
-
-      FileUtils.mkdir_p(RuntimeProfiler.output_path)
-      filename = ['runtime-profiling', Process.pid, Time.now.to_i].join('-') << '.json'
-      output_file = File.join(RuntimeProfiler.output_path, filename)
-
-      File.open(output_file, 'w') do |f|
-        f.write JSON.dump(instrumentation_data)
-      end
-
-      puts "\n"
-      puts '~~~~> [ Profiling RUNTIME ] Profiling now COMPLETE and JSON report is written at ' + output_file.to_s
-      puts '~~~~> [ Profiling RUNTIME ]'
-      puts '~~~~> [ Profiling RUNTIME ] You can do the following to view the JSON report in console:'
-      puts '~~~~> [ Profiling RUNTIME ]'
-      puts '~~~~> [ Profiling RUNTIME ]     bundle exec runtime_profiler view ' + output_file.to_s
-      puts '~~~~> [ Profiling RUNTIME ]'
-      puts '~~~~> [ Profiling RUNTIME ] Or'
-      puts '~~~~> [ Profiling RUNTIME ]'
-      puts '~~~~> [ Profiling RUNTIME ]     bundle exec runtime_profiler view --help'
-      puts '~~~~> [ Profiling RUNTIME ]'
-      puts '~~~~> [ Profiling RUNTIME ] for more details.'
     end
 
-    private
-
     def method_calls_data
       @method_calls_data ||= begin
-        instrumented_methods = {}
+        profiled_methods = {}
 
         # TODO: Group methods under a key and under an object
-        MethodMeter.measurement.each do |measurement|
-          measurement.each_pair do |key, data|
-            data.each do |d|
-              object = d[:method].split(separator = '.')
-              object = d[:method].split(separator = '#') if object.length == 1
-
-              d[:method] = separator + object.second
-
-              if instrumented_methods[object.first]
-                instrumented_methods[object.first] << d
-              else
-                instrumented_methods[object.first] = [d]
-              end
+        MethodMeter.measurement.each_pair do |key, data|
+          data.each do |d|
+            object = d[:method].split(separator = '.')
+            object = d[:method].split(separator = '#') if object.length == 1
+
+            d[:method] = separator + object.second
+
+            if profiled_methods[object.first]
+              profiled_methods[object.first] << d
+            else
+              profiled_methods[object.first] = [d]
             end
           end
         end
 
-        instrumented_methods = instrumented_methods.inject({}) do |hash, (key, value)|
+        profiled_methods = profiled_methods.inject({}) do |hash, (key, value)|
           val = value.sort { |a, b| b[:total_runtime] <=> a[:total_runtime] }
           hash[key] = val
           hash
@@ -88,7 +85,7 @@ module RuntimeProfiler
         slowest_method = {total_runtime: 0}
         mostly_called_method = {total_calls: 0}
 
-        instrumented_methods.each do |profiled_object_name, methods|
+        profiled_methods.each do |profiled_object_name, methods|
           # sort using `total_runtime` in DESC order
           _methods = methods.sort { |a, b| b[:total_runtime] <=> a[:total_runtime] }
           slowest = _methods[0]
@@ -111,7 +108,7 @@ module RuntimeProfiler
         end
 
         {
-          instrumented_methods: instrumented_methods,
+          profiled_methods: profiled_methods,
                 slowest_method: slowest_method,
           mostly_called_method: mostly_called_method
         }
@@ -120,7 +117,7 @@ module RuntimeProfiler
 
     def sql_calls_data
       @sql_calls_data ||= begin
-        instrumented_sql_calls = []
+        profiled_sql_calls = []
 
         slowest_sql = {total_runtime: 0}
         mostly_called_sql = {total_calls: 0}
@@ -141,7 +138,7 @@ module RuntimeProfiler
             slowest_sql[:source]        = slowest[1]
           end
 
-          instrumented_sql_calls << {
+          profiled_sql_calls << {
                       sql: value[:sql],
                  runtimes: runtimes,
               total_calls: total_calls,
@@ -163,9 +160,9 @@ module RuntimeProfiler
         end
 
         {
-          instrumented_sql_calls: instrumented_sql_calls.sort { |a, b| b[:max] <=> a[:max] },
-                 total_sql_calls: instrumented_sql_calls.map { |sql_call| sql_call[:total_calls] }.reduce(:+),
-          total_unique_sql_calls: instrumented_sql_calls.size,
+          profiled_sql_calls: profiled_sql_calls.sort { |a, b| b[:max] <=> a[:max] },
+                 total_sql_calls: profiled_sql_calls.map { |sql_call| sql_call[:total_calls] }.reduce(:+),
+          total_unique_sql_calls: profiled_sql_calls.size,
                      slowest_sql: slowest_sql,
                mostly_called_sql: mostly_called_sql
         }

data/lib/runtime_profiler/events/process_action_event.rb

@@ -30,4 +30,4 @@ module RuntimeProfiler
       @key ||= Digest::MD5.hexdigest(path.downcase)
     end
   end
-end
+end

data/lib/runtime_profiler/events/sql_event.rb

@@ -10,8 +10,8 @@ module RuntimeProfiler
     end
 
     def recordable?
-      return true unless RuntimeProfiler.instrumented_sql_commands.respond_to?(:join)
-      instrumented_sql_matcher =~ sql
+      return true unless RuntimeProfiler.profiled_sql_commands.respond_to?(:join)
+      profiled_sql_matcher =~ sql
     end
 
     def total_runtime
@@ -41,12 +41,12 @@ module RuntimeProfiler
       @sql ||= @payload[:sql].dup
     end
 
-    def instrumented_sql_matcher
-      @instrumented_sql_matcher ||= /\A#{RuntimeProfiler.instrumented_sql_commands.join('|')}/i
+    def profiled_sql_matcher
+      @profiled_sql_matcher ||= /\A#{RuntimeProfiler.profiled_sql_commands.join('|')}/i
     end
 
     def trace_path_matcher
-      @trace_path_matcher ||= %r{^(#{RuntimeProfiler.instrumented_paths.join('|')})\/}
+      @trace_path_matcher ||= %r{^(#{RuntimeProfiler.profiled_paths.join('|')})\/}
     end
 
     def sanitize_trace!(trace)
@@ -59,7 +59,7 @@ module RuntimeProfiler
 
       Rails.backtrace_cleaner.remove_silencers!
 
-      if RuntimeProfiler.instrumented_paths.respond_to?(:join)
+      if RuntimeProfiler.profiled_paths.respond_to?(:join)
         Rails.backtrace_cleaner.add_silencer do |line|
           line !~ trace_path_matcher
         end

data/lib/runtime_profiler/profiler.rb

@@ -1,55 +1,64 @@
-# require 'method_profiler'
+require 'method_meter'
 
 require 'runtime_profiler/callbacks/active_record'
 require 'runtime_profiler/callbacks/action_controller'
-require 'runtime_profiler/instrumentation_data'
+require 'runtime_profiler/data'
 
 module RuntimeProfiler
   class Profiler
-    attr_accessor :instrumented_constants
+    attr_accessor :profiled_constants
 
-    def initialize(konstants)
-      self.instrumented_constants = konstants
+    def initialize(constants)
+      self.profiled_constants = constants
+      prepare_for_profiling
     end
 
-    def prepare_for_instrumentation
-      subscribe_to_event_notifications
-      prepare_methods_to_instrument
+    def profile!(key)
+      MethodMeter.measure!(key) { yield }
+      save_profiling_data
     end
 
-    def subscribe_to_event_notifications
+    private
+
+    def prepare_for_profiling
+      subscribe_to_rails_event_notifications
+      prepare_methods_to_profile
+    end
+
+    def subscribe_to_rails_event_notifications
       @subscribers = []
 
       @active_record_callback = Callback::ActiveRecord.new
 
       @subscribers << ActiveSupport::Notifications
-        .subscribe('sql.active_record', @active_record_callback)
+                      .subscribe('sql.active_record', @active_record_callback)
 
       @action_controller_callback = Callback::ActionController.new
 
       @subscribers << ActiveSupport::Notifications
-        .subscribe('process_action.action_controller', @action_controller_callback)
+                      .subscribe('process_action.action_controller', @action_controller_callback)
     end
 
-    def unsubscribe_to_event_notifications
+    def unsubscribe_to_rails_event_notifications
       @subscribers.each do |subscriber|
         ActiveSupport::Notifications.unsubscribe(subscriber)
       end
     end
 
-    def prepare_methods_to_instrument
-      self.instrumented_constants.flatten
-        .each { |constant| MethodMeter.observe(constant) }
+    def prepare_methods_to_profile
+      profiled_constants
+        .flatten
+        .each { |constant| MethodMeter.observe(constant, RuntimeProfiler.excepted_methods) }
     end
 
-    def save_instrumentation_data
-      unsubscribe_to_event_notifications
+    def save_profiling_data
+      unsubscribe_to_rails_event_notifications
 
-      instrumentation_data = RuntimeProfiler::InstrumentationData.new \
-         controller_data: @action_controller_callback.controller_data,
-                sql_data: @active_record_callback.data
+      profiling_data = RuntimeProfiler::Data.new \
+        controller_data: @action_controller_callback.controller_data,
+        sql_data: @active_record_callback.data
 
-      instrumentation_data.persist!
+      profiling_data.persist!
     end
   end
-end
+end

data/lib/runtime_profiler/text_report.rb

@@ -26,12 +26,12 @@ module RuntimeProfiler
         \e[1mSQL CALLS\e[22m
           Total             : %s
           Total Unique      : %s
-          
+
           \e[1mSLOWEST\e[22m
             Total Runtime   : %s ms
             SQL             : %s
             Source          : %s
-          
+
           \e[1mMOSTLY CALLED\e[22m
             Total Calls     : %s
             Total Runtime   : %s ms
@@ -86,7 +86,7 @@ module RuntimeProfiler
     attr_accessor :data, :options
 
     def initialize(json_file, options)
-      self.data = JSON.parse( File.read(json_file) )
+      self.data = JSON.parse(File.read(json_file))
       self.options = options
     end
 
@@ -95,12 +95,12 @@ module RuntimeProfiler
 
       if options.details == 'full'
         if only_methods?
-          print_instrumented_methods
+          print_profiled_methods
         elsif only_sqls?
-          print_instrumented_sql_calls
+          print_profiled_sql_calls
         else
-          print_instrumented_methods
-          print_instrumented_sql_calls
+          print_profiled_methods
+          print_profiled_sql_calls
         end
       end
     end
@@ -121,34 +121,34 @@ module RuntimeProfiler
 
     def print_summary
       summary = if only_methods?
-        METHODS_DETAILS_TEMPLATE % details_template_data
-      elsif only_sqls?
-        SQLS_DETAILS_TEMPLATE % details_template_data
-      else
-        FULL_DETAILS_TEMPLATE % details_template_data
-      end
+                  METHODS_DETAILS_TEMPLATE % details_template_data
+                elsif only_sqls?
+                  SQLS_DETAILS_TEMPLATE % details_template_data
+                else
+                  FULL_DETAILS_TEMPLATE % details_template_data
+                end
       puts summary
     end
 
-    def print_instrumented_methods
-      instrumented_methods = []
+    def print_profiled_methods
+      profiled_methods = []
 
-      data['instrumentation']['instrumented_methods'].each do |profiled_object_name, methods|
-        _instrumented_methods = methods.map do |method|
+      data['profiling']['profiled_methods'].each do |profiled_object_name, methods|
+        _profiled_methods = methods.map do |method|
           method['method'] = [profiled_object_name, method['method']].join
           method
         end
-        instrumented_methods.concat(_instrumented_methods)
+        profiled_methods.concat(_profiled_methods)
       end
 
-      instrumented_methods = runtime_above(instrumented_methods) if options.runtime_above.presence > 0
-      instrumented_methods = calls_above(instrumented_methods) if options.calls_above.presence > 0
-      instrumented_methods = sort(instrumented_methods)
+      profiled_methods = runtime_above(profiled_methods) if options.runtime_above.presence > 0
+      profiled_methods = calls_above(profiled_methods) if options.calls_above.presence > 0
+      profiled_methods = sort(profiled_methods)
 
       table = Terminal::Table.new do |t|
         t.headings = ['Method', 'Total Runtime (ms)', 'Total Calls', 'Min (ms)', 'Max (ms)']
 
-        instrumented_methods.each_with_index do |row, index|
+        profiled_methods.each_with_index do |row, index|
           t.add_row [
             row['method'],
             row['total_runtime'].round(rounding),
@@ -156,29 +156,28 @@ module RuntimeProfiler
             row['min'].round(rounding),
             row['max'].round(rounding)
           ]
-          t.add_separator if index < instrumented_methods.size - 1
+          t.add_separator if index < profiled_methods.size - 1
         end
-
       end
 
       puts
       puts
-      puts "\e[1mINSTRUMENTED METHOD(s)\e[22m"
+      puts "\e[1mPROFILED METHOD(s)\e[22m"
       puts
       puts table
     end
 
-    def print_instrumented_sql_calls
-      instrumented_sql_calls = data['instrumentation']['instrumented_sql_calls']
+    def print_profiled_sql_calls
+      profiled_sql_calls = data['profiling']['profiled_sql_calls']
 
-      instrumented_sql_calls = runtime_above(instrumented_sql_calls) if options.runtime_above.presence > 0
-      instrumented_sql_calls = calls_above(instrumented_sql_calls) if options.calls_above.presence > 0
-      instrumented_sql_calls = sort(instrumented_sql_calls, false)
+      profiled_sql_calls = runtime_above(profiled_sql_calls) if options.runtime_above.presence > 0
+      profiled_sql_calls = calls_above(profiled_sql_calls) if options.calls_above.presence > 0
+      profiled_sql_calls = sort(profiled_sql_calls, false)
 
       table = Terminal::Table.new do |t|
-        t.headings = ['Count', 'Total Runtime (ms)', 'Average Runtime (ms)', 'SQL Query', 'Source']
+        t.headings = ['SQL Query', 'Count', 'Total Runtime (ms)', 'Average Runtime (ms)', 'Source']
 
-        instrumented_sql_calls.each_with_index do |row, index|
+        profiled_sql_calls.each_with_index do |row, index|
           chopped_sql       = wrap_text(row['sql'], sql_width)
           source_list       = wrap_list(row['runtimes'].map { |runtime| runtime[1] }.uniq, sql_width - 15)
           average_runtime   = row['average'].round(rounding)
@@ -192,29 +191,29 @@ module RuntimeProfiler
           (0...total_lines).each do |line|
             count         = line == 0                 ? row['total_calls']    : ''
             average       = line == 0                 ? average_runtime       : ''
-            total_runtime = line == 0                 ? total_runtime  : ''
+            total_runtime = line == 0                 ? total_runtime : ''
             source        = source_list.length > line ? source_list[line]     : ''
             query         = row['sql'].length > line  ? chopped_sql[line]     : ''
 
             t.add_row []
-            t.add_row [count, total_runtime, average, query, source]
+            t.add_row [query, count, total_runtime, average, source]
           end
 
           t.add_row []
-          t.add_separator if index < instrumented_sql_calls.size - 1
+          t.add_separator if index < profiled_sql_calls.size - 1
         end
-
       end
 
       puts
       puts
-      puts "\e[1mINSTRUMENTED SQL(s)\e[22m"
+      puts "\e[1mPROFILED SQL(s)\e[22m"
       puts
       puts table
     end
 
     def wrap_text(text, width)
       return [text] if text.length <= width
+
       text.scan(/.{1,#{width}}/)
     end
 
@@ -231,7 +230,7 @@ module RuntimeProfiler
       end
     end
 
-    def sort(data, methods=true)
+    def sort(data, methods = true)
       if methods
         data.sort_by do |d|
           if options.sort_by == 'max_runtime'
@@ -243,8 +242,8 @@ module RuntimeProfiler
           end
         end
       else
-         options.sort_by = 'total_runtime' if options.sort_by == 'max_runtime'
-        data.sort_by { |d| options.sort_by == 'total_runtime' ?  -d['total_runtime'] : -d['total_calls'] }
+        options.sort_by = 'total_runtime' if options.sort_by == 'max_runtime'
+        data.sort_by { |d| options.sort_by == 'total_runtime' ? -d['total_runtime'] : -d['total_calls'] }
       end
     end
 
@@ -257,7 +256,7 @@ module RuntimeProfiler
     end
 
     def details_template_data
-      summary = data['instrumentation']['summary']
+      summary = data['profiling']['summary']
 
       template_data = [
         summary['total_runtime'] ? summary['total_runtime'].round(rounding) : 'n/a',

data/lib/runtime_profiler/version.rb

@@ -1,3 +1,3 @@
 module RuntimeProfiler
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.4'.freeze
 end

data/runtime_profiler.gemspec

@@ -1,5 +1,4 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'runtime_profiler/version'
 
@@ -19,15 +18,16 @@ Gem::Specification.new do |spec|
   spec.executables   = ['runtime_profiler']
   spec.require_paths = ['lib']
 
+  spec.add_development_dependency 'activesupport', '>= 3.0.0'
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake', '>= 12.3.3'
   spec.add_development_dependency 'minitest', '~> 5.0'
-  spec.add_development_dependency 'activesupport', '>= 3.0.0'
-  spec.add_development_dependency 'pry'
   spec.add_development_dependency 'minitest-line'
-  spec.add_runtime_dependency 'terminal-table'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
+  spec.add_development_dependency 'rubocop'
   spec.add_runtime_dependency 'commander'
-  spec.add_runtime_dependency 'hirb'
-  spec.add_runtime_dependency 'method_meter'
   spec.add_runtime_dependency 'defined_methods'
+  spec.add_runtime_dependency 'hirb'
+  spec.add_runtime_dependency 'method_meter', '>= 0.4.3'
+  spec.add_runtime_dependency 'terminal-table'
 end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: runtime_profiler
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.4
 platform: ruby
 authors:
 - Wilfrido T. Nuqui Jr.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-04 00:00:00.000000000 Z
+date: 2021-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 3.0.0
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 12.3.3
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -53,19 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: minitest-line
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -81,7 +81,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest-line
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 12.3.3
+- !ruby/object:Gem::Dependency
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,7 +109,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: terminal-table
+  name: commander
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -109,7 +123,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: commander
+  name: defined_methods
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -142,16 +156,16 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.4.3
 - !ruby/object:Gem::Dependency
-  name: defined_methods
+  name: terminal-table
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -185,12 +199,13 @@ files:
 - lib/runtime_profiler/callbacks/action_controller.rb
 - lib/runtime_profiler/callbacks/active_record.rb
 - lib/runtime_profiler/cli.rb
+- lib/runtime_profiler/data.rb
 - lib/runtime_profiler/events/process_action_event.rb
 - lib/runtime_profiler/events/sql_event.rb
-- lib/runtime_profiler/instrumentation_data.rb
 - lib/runtime_profiler/profiler.rb
 - lib/runtime_profiler/text_report.rb
 - lib/runtime_profiler/version.rb
+- rp_view_command.png
 - runtime_profiler.gemspec
 homepage: http://www.github.com/wnuqui/runtime_profiler
 licenses: