runtime_profiler 0.1.4 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e33ac72fec2841f6fb3c5b50ae46aece8bd6902ff177392dfc056e7f6ae336d6
-  data.tar.gz: 1053411fdb7d59d1c54f9c89cd1f465dbf8cc1b280bf9d42a93ee5055fc223bf
+  metadata.gz: 10844b957c031772b37b68bfe5f2c83fc98c25c40c709eea8e6920badd400b04
+  data.tar.gz: 52b61fe38de36b0f97fa16bbe742e3baa5e4444f22db6fa64e577deddeba491a
 SHA512:
-  metadata.gz: 430be7e054bd7748c36bf468bf28d134d35a43a441d5d3fff6730e29d15d173a74ce5e64b8e3711ff63291b10dc8c3977f58a3caecff6c649936f632d7b15be7
-  data.tar.gz: b2d7f4f5019f489def998d8858bbec09c99be054289429482858836a0e88a2e49e22626e2f31461cedf4e9f5473eafb8baac4e0818528c2aec04a824d68683d7
+  metadata.gz: 289e5c785b16a2fb16ff17af9c1d7dbb02d765cf6990bac5ad1c7f4f6005042ff8589a80b79f54b7473705b5323adfb93b49cd31f4fa3e3934d9df15dbb31a6c
+  data.tar.gz: 5b783916251fafdf991f7a3cca98336bc329ce96ff4b1efcb4f215dc2924439c3dabe797f66502956b4169bb72bc60512f3a7b7b04740463a65cb5c60a803353

data/.semaphore/semaphore.yml

@@ -0,0 +1,18 @@
+version: v1.0
+name: Ruby
+agent:
+  machine:
+    type: e1-standard-2
+    os_image: ubuntu1804
+blocks:
+  - name: test
+    task:
+      jobs:
+        - name: test
+          commands:
+            - checkout
+            - sem-version ruby 2.6.5
+            - cache restore
+            - bundle install --path vendor/bundle
+            - cache store
+            - bundle exec rake

data/README.md

@@ -1,20 +1,36 @@
-# runtime_profiler - Runtime Profiler for Rails Applications
+# runtime_profiler
 
-`runtime_profiler` instruments api or a method of your Rails application using Rails' `ActiveSupport::Notifications`
+*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.
 
-## Note
+[![Build Status](https://wnuqui.semaphoreci.com/badges/runtime_profiler/branches/master.svg?style=shields)](https://wnuqui.semaphoreci.com/projects/runtime_profiler)
 
-This is still a **work in progress**. However, this is a tool meant to be used in development so it is safe to use.
+## Table of contents
 
-## Installation
+- [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
 ```
@@ -23,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).
+
+```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
 
-To start profiling, make a test and use `RuntimeProfiler.profile!` method in the tests. The output of instrumentation will be generated under the `tmp` folder of your application.
+You can make a test that targets a particular endpoint (or even just a method) and use `RuntimeProfiler.profile!` method in the test.
 
-Example:
 ```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' }
   }
@@ -38,24 +74,86 @@ it 'updates user' do
 end
 ```
 
-Run tests as usual and follow printed instructions after running tests.
+Run the test as usual and follow printed instructions after running.
+
+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 (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
+
+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 tmp/rp-124094-1608308786.json
+```
 
-## Reporting
+#### view options
 
-To see profiling/instrumenting report, please open the report in browser with JSON viewer report. Or you can run the following command:
+Here are the command line options for `runtime_profiler view` command.
 
 ```bash
-bundle exec runtime_profiler view ~/the-rails-app/tmp/runtime-profiling-51079-1521371428.json
+$ bundle exec runtime_profiler view --help
+
+  NAME:
+
+    view
+
+  SYNOPSIS:
+
+    runtime_profiler view <profile.report.json> [options]
+
+  DESCRIPTION:
+
+    Display report in console given the JSON report file
+
+  OPTIONS:
+
+    --sort-by COLUMN
+        Sort by COLUMN. COLUMN can be "max_runtime", total_calls" or "total_runtime". Default is "max_runtime".
+
+    --details TYPE
+        TYPE can be "full" or "summary". Default is "summary"
+
+    --only-sqls
+        Show only SQL queries. Default is false.
+
+    --only-methods
+        Show only methods. Default is false.
+
+    --runtime-above RUNTIME
+        RUNTIME is integer or float value in ms.
+
+    --calls-above CALLS
+        CALLS is integer value.
+
+    --rounding ROUNDING
+        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:
+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

@@ -6,52 +6,48 @@ 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
+      profiler.prepare_for_profiling
 
       MethodMeter.measure!(key) { yield }
 
-      profiler.save_instrumentation_data
-    end
-
-    def runtime(label='for the block')
-      result = nil
-
-      elapsed_time = Benchmark.realtime { result = yield }
-
-      puts
-      puts '~~~~> ELAPSED TIME (%s): %s' % [label, elapsed_time * 1000]
-      puts
-
-      result
+      profiler.save_profiling_data
     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

@@ -16,32 +16,37 @@ module RuntimeProfiler
         c.syntax = 'runtime_profiler view <profile.report.json> [options]'
         c.description = 'Display report in console given the JSON report file'
 
-        c.option '--sort-by COLUMN',        String, 'Sort by COLUMN. COLUMN can either be "total_calls" or "total_runtime". Default is "total_calls".'
-        c.option '--details TYPE',          String, 'TYPE can be "full" or "summary".'
-        c.option '--runtime-above RUNTIME', String, 'RUNTIME is numeric value in ms.'
-        c.option '--only-sqls',             String, 'Show only SQL(s).'
-        c.option '--only-methods',          String, 'Show only method(s).'
-        c.option '--calls-above CALLS',     String, 'CALLS is numeric value.'
+        c.option '--sort-by COLUMN',        String,   'Sort by COLUMN. COLUMN can be "max_runtime", total_calls" or "total_runtime". Default is "max_runtime".'
+        c.option '--details TYPE',          String,   'TYPE can be "full" or "summary". Default is "summary"'
+        c.option '--only-sqls',             String,   'Show only SQL queries. Default is false.'
+        c.option '--only-methods',          String,   'Show only methods. Default is false.'
+        c.option '--runtime-above RUNTIME', Float,    'RUNTIME is integer or float value in ms.'
+        c.option '--calls-above CALLS',     Integer,  'CALLS is integer value.'
+        c.option '--rounding ROUNDING',     Integer,  'ROUNDING is integer value. Used in rounding runtimes. Default is 4.'
 
         c.action do |args, options|
           default_options = {
-            sort_by: 'total_calls',
+            sort_by: 'max_runtime',
             details: 'summary',
             runtime_above: 0,
             only_sqls: false,
             only_methods: false,
-            calls_above: 1
+            calls_above: 0,
+            rounding: 4
           }
 
           options.default default_options
 
-          report = RuntimeProfiler::TextReport.new(args.first, options)
-
-          report.print
+          if args.first.nil?
+            say 'You need to supply <profile.report.json> as first argument of view.'
+          else
+            report = RuntimeProfiler::TextReport.new(args.first, options)
+            report.print
+          end
         end
       end
 
       run!
     end
   end
-end
+end

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

@@ -1,18 +1,43 @@
 module RuntimeProfiler
-  class InstrumentationData
+  class Data
     attr_reader :controller_data, :sql_data
 
     def initialize(controller_data: nil, sql_data: nil)
-      @controller_data = controller_data
+      @controller_data = controller_data || {}
       @sql_data = sql_data
     end
 
     def persist!
-      instrumented_api = [controller_data[:payload][:controller], controller_data[:payload][:action]].join('#')
+      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
 
-      instrumentation_data = {
-        instrumentation: {
-          instrumented_api: instrumented_api,
+    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('#')
+    end
+
+    def profiling_data
+      @profiling_data ||= {
+        profiling: {
+          profiled_api: profiled_api,
           summary: {
                         db_runtime: controller_data[:db_runtime],
                       view_runtime: controller_data[:view_runtime],
@@ -24,38 +49,16 @@ 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 '~~~~> [ Profiling RUNTIME ] Profiling now COMPLETE and JSON report 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|
@@ -66,16 +69,16 @@ module RuntimeProfiler
 
               d[:method] = separator + object.second
 
-              if instrumented_methods[object.first]
-                instrumented_methods[object.first] << d
+              if profiled_methods[object.first]
+                profiled_methods[object.first] << d
               else
-                instrumented_methods[object.first] = [d]
+                profiled_methods[object.first] = [d]
               end
             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
@@ -84,7 +87,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]
@@ -107,7 +110,7 @@ module RuntimeProfiler
         end
 
         {
-          instrumented_methods: instrumented_methods,
+          profiled_methods: profiled_methods,
                 slowest_method: slowest_method,
           mostly_called_method: mostly_called_method
         }
@@ -116,7 +119,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}
@@ -137,7 +140,7 @@ module RuntimeProfiler
             slowest_sql[:source]        = slowest[1]
           end
 
-          instrumented_sql_calls << {
+          profiled_sql_calls << {
                       sql: value[:sql],
                  runtimes: runtimes,
               total_calls: total_calls,
@@ -159,9 +162,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

@@ -2,19 +2,19 @@
 
 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
     end
 
-    def prepare_for_instrumentation
+    def prepare_for_profiling
       subscribe_to_event_notifications
-      prepare_methods_to_instrument
+      prepare_methods_to_profile
     end
 
     def subscribe_to_event_notifications
@@ -23,12 +23,12 @@ module RuntimeProfiler
       @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
@@ -37,19 +37,19 @@ module RuntimeProfiler
       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
+    def save_profiling_data
       unsubscribe_to_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

@@ -1,6 +1,7 @@
 require 'hirb'
 require 'terminal-table'
 require 'active_support/core_ext/string'
+require 'pry'
 
 module RuntimeProfiler
   class TextReport
@@ -8,29 +9,72 @@ module RuntimeProfiler
     DURATION_WIDTH      = 22
     TOTAL_RUNTIME_WIDTH = 20
 
-    SUMMARY_TEMPLATE = <<-EOT.strip_heredoc
+    FULL_DETAILS_TEMPLATE = <<-EOT.strip_heredoc
 
         \e[1mPROFILING REPORT\e[22m
         ----------------
 
-        \e[1mRUNTIME\e[22m
+        \e[1mAPI RUNTIME\e[22m
           Total Runtime     : %s ms
           Database Runtime  : %s ms
           View Runtime      : %s ms
 
-        \e[1mMETHODS\e[22m
+        \e[1mMETHOD CALLS\e[22m
           SLOWEST           : %s (%s ms)
           MOSTLY CALLED     : %s (%s number of calls in %s ms)
 
         \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
+            SQL             : %s
+            Sources         : %s
+
+      EOT
+
+    METHODS_DETAILS_TEMPLATE = <<-EOT.strip_heredoc
+
+        \e[1mPROFILING REPORT\e[22m
+        ----------------
+
+        \e[1mAPI RUNTIME\e[22m
+          Total Runtime     : %s ms
+          Database Runtime  : %s ms
+          View Runtime      : %s ms
+
+        \e[1mMETHOD CALLS\e[22m
+          SLOWEST           : %s (%s ms)
+          MOSTLY CALLED     : %s (%s number of calls in %s ms)
+
+      EOT
+
+    SQLS_DETAILS_TEMPLATE = <<-EOT.strip_heredoc
+
+        \e[1mPROFILING REPORT\e[22m
+        ----------------
+
+        \e[1mAPI RUNTIME\e[22m
+          Total Runtime     : %s ms
+          Database Runtime  : %s ms
+          View Runtime      : %s ms
+
+        \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
@@ -42,68 +86,102 @@ module RuntimeProfiler
     attr_accessor :data, :options
 
     def initialize(json_file, options)
-      self.data = JSON.parse( File.read(json_file) )
-      self.options  = options
+      self.data = JSON.parse(File.read(json_file))
+      self.options = options
     end
 
     def print
       print_summary
 
-      if self.options.details == 'full'
-        print_instrumented_methods
-        print_instrumented_sql_calls
+      if options.details == 'full'
+        if only_methods?
+          print_profiled_methods
+        elsif only_sqls?
+          print_profiled_sql_calls
+        else
+          print_profiled_methods
+          print_profiled_sql_calls
+        end
       end
     end
 
     private
 
+    def only_methods?
+      options.only_methods.present? && options.only_sqls.blank?
+    end
+
+    def only_sqls?
+      options.only_sqls.present? && options.only_methods.blank?
+    end
+
+    def rounding
+      options.rounding
+    end
+
     def print_summary
-      summary = SUMMARY_TEMPLATE % summary_template_data
+      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
       puts summary
     end
 
-    def print_instrumented_methods
-      instrumented_methods = []
+    def print_profiled_methods
+      profiled_methods = []
 
-      self.data['instrumentation']['instrumented_methods'].each do |profiled_object_name, methods|
-        instrumented_methods.concat methods.map { |method| method['method'] = [profiled_object_name, method['method']].join; 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
+        profiled_methods.concat(_profiled_methods)
       end
 
-      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', 'Max']
+        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'],
+            row['total_runtime'].round(rounding),
             row['total_calls'],
-            row['min'],
-            row['max']
+            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 = sort(self.data['instrumentation']['instrumented_sql_calls'])
+    def print_profiled_sql_calls
+      profiled_sql_calls = data['profiling']['profiled_sql_calls']
+
+      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(2)
+          average_runtime   = row['average'].round(rounding)
+          total_runtime     = row['total_runtime'].round(rounding)
           total_lines       = if chopped_sql.length >= source_list.length
                                 chopped_sql.length
                               else
@@ -113,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                 ? row['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
 
@@ -152,43 +230,72 @@ module RuntimeProfiler
       end
     end
 
-    def sort(data)
-      data.sort_by do |d|
-        if self.options.sort_by == 'total_runtime'
-          -d['total_runtime']
-        else
-          -d['total_calls']
+    def sort(data, methods = true)
+      if methods
+        data.sort_by do |d|
+          if options.sort_by == 'max_runtime'
+            -d['max']
+          elsif options.sort_by == 'total_runtime'
+            -d['total_runtime']
+          elsif options.sort_by == 'total_calls'
+            -d['total_calls']
+          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'] }
       end
     end
 
-    def summary_template_data
-      summary = self.data['instrumentation']['summary']
+    def runtime_above(data)
+      data.select { |d| d['total_runtime'] > options.runtime_above }
+    end
+
+    def calls_above(data)
+      data.select { |d| d['total_calls'] > options.calls_above }
+    end
+
+    def details_template_data
+      summary = data['profiling']['summary']
 
-      [
-        summary['total_runtime'].round(2),
-        summary['db_runtime'].round(2),
-        summary['view_runtime'].round(2),
+      template_data = [
+        summary['total_runtime'] ? summary['total_runtime'].round(rounding) : 'n/a',
+        summary['db_runtime'] ? summary['db_runtime'].round(rounding) : 'n/a',
+        summary['view_runtime'] ? summary['view_runtime'].round(rounding) : 'n/a'
+      ]
 
+      methods_data = [
         summary['slowest_method']['method'],
-        summary['slowest_method']['total_runtime'].round(2),
+        summary['slowest_method']['total_runtime'].round(rounding),
 
         summary['mostly_called_method']['method'],
         summary['mostly_called_method']['total_calls'],
-        summary['mostly_called_method']['total_runtime'].round(2),
+        summary['mostly_called_method']['total_runtime'].round(rounding)
+      ]
 
+      sqls_data = [
         summary['total_sql_calls'],
         summary['total_unique_sql_calls'],
 
-        summary['slowest_sql']['total_runtime'].round(2),
+        summary['slowest_sql']['total_runtime'].round(rounding),
         summary['slowest_sql']['sql'],
         summary['slowest_sql']['source'],
 
         summary['mostly_called_sql']['total_calls'],
-        summary['mostly_called_sql']['total_runtime'].round(2),
+        summary['mostly_called_sql']['total_runtime'].round(rounding),
         summary['mostly_called_sql']['sql'],
         summary['mostly_called_sql']['runtimes'].map { |runtime| runtime[1] }.uniq
       ]
+
+      if only_methods?
+        template_data.concat(methods_data)
+      elsif only_sqls?
+        template_data.concat(sqls_data)
+      else
+        template_data
+          .concat(methods_data)
+          .concat(sqls_data)
+      end
     end
   end
 end

data/lib/runtime_profiler/version.rb

@@ -1,3 +1,3 @@
 module RuntimeProfiler
-  VERSION = '0.1.4'.freeze
+  VERSION = '0.4.3'.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 'bundler', '~> 1.12'
-  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 'bundler'
+  spec.add_development_dependency 'minitest', '~> 5.0'
   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 'defined_methods'
   spec.add_runtime_dependency 'hirb'
   spec.add_runtime_dependency 'method_meter'
-  spec.add_runtime_dependency 'defined_methods'
+  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.1.4
+  version: 0.4.3
 platform: ruby
 authors:
 - Wilfrido T. Nuqui Jr.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-14 00:00:00.000000000 Z
+date: 2021-01-02 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: '1.12'
+        version: 3.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.12'
+        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:
     - - ">="
@@ -151,7 +165,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: defined_methods
+  name: terminal-table
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -173,6 +187,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".semaphore/semaphore.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -184,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: