runtime_profiler 0.1.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f0d303faf46e8b0eec88384965d29c5136390166
-  data.tar.gz: 1653ba57d2cbf4b10dd9c8da35310e2ec6d20f00
+SHA256:
+  metadata.gz: cfc4edf1ad5783057cfd0760d11e49a8d91665b71c33b6e809a0796a7d51cb83
+  data.tar.gz: cb19a035d46cae60fd4d16c626fac305a47fab4aaf28134feb47883a9f8a5d94
 SHA512:
-  metadata.gz: ecdf3e02b864efeec7f8dacc7b96c443c6baaa39a4931af40cb3d720d6519f5094b2f2f10cdb884cc3f3ecb305440b59f4dfe968df9aeb92e3900536fa8814b6
-  data.tar.gz: 26fe71304d4b511468385739f163033f9bc7ec3562168d844068aac47fcb4bd9c540ade25b7cf6dd5ebac05d8184965f740689f4f5d27ebde1eecd1cc1b48a65
+  metadata.gz: 1d85ca30cfa19fab9739ca87d6fb0fd1e4cddcf43ed0c5af8c1eab7d867ab24e5dfb11c4e0ad37cbac48a5bf5c149214e40899bd5e4e0a5555bef22d68efd60f
+  data.tar.gz: 6f3ab5d14e1cb231bd4c55156270190346d1de5f1aac3a4c3b09ca992ec577e105b35197a24022f63687034bb07df2f168249a6f72b5adb3ee8a97d4e79282d2

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,19 +74,79 @@ 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_only_methods_full_details.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]

data/lib/runtime_profiler.rb

@@ -11,24 +11,32 @@ module RuntimeProfiler
   end
 
   config_accessor :instrumented_paths do
-    %w(app lib)
+    %w[app lib]
   end
 
   config_accessor :instrumented_sql_commands do
-    %w(SELECT INSERT UPDATE DELETE)
+    %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
 
@@ -41,17 +49,5 @@ module RuntimeProfiler
 
       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
-    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/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

@@ -1,3 +1,5 @@
+require 'digest'
+
 module RuntimeProfiler
   class SqlEvent
     attr_reader :started_at, :finished_at, :payload, :trace

data/lib/runtime_profiler/instrumentation_data.rb

@@ -3,14 +3,39 @@ module RuntimeProfiler
     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(instrumentation_data)
+      end
 
-      instrumentation_data = {
+      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 instrumented_api
+      return unless controller_data[:payload]
+      @instrumented_api ||= [
+        controller_data[:payload][:controller],
+        controller_data[:payload][:action]
+      ].join('#')
+    end
+
+    def instrumentation_data
+      @instrumentation_data ||= {
         instrumentation: {
           instrumented_api: instrumented_api,
           summary: {
@@ -29,30 +54,8 @@ module RuntimeProfiler
           instrumented_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 = {}

data/lib/runtime_profiler/profiler.rb

@@ -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
@@ -38,18 +38,18 @@ module RuntimeProfiler
     end
 
     def prepare_methods_to_instrument
-      self.instrumented_constants.flatten
-        .each { |constant| MethodMeter.observe(constant) }
+      instrumented_constants.flatten
+                            .each { |constant| MethodMeter.observe(constant, RuntimeProfiler.excepted_methods) }
     end
 
     def save_instrumentation_data
       unsubscribe_to_event_notifications
 
       instrumentation_data = RuntimeProfiler::InstrumentationData.new \
-         controller_data: @action_controller_callback.controller_data,
-                sql_data: @active_record_callback.data
+        controller_data: @action_controller_callback.controller_data,
+        sql_data: @active_record_callback.data
 
       instrumentation_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,49 +86,78 @@ 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_instrumented_methods
+        elsif only_sqls?
+          print_instrumented_sql_calls
+        else
+          print_instrumented_methods
+          print_instrumented_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 = []
 
-      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['instrumentation']['instrumented_methods'].each do |profiled_object_name, methods|
+        _instrumented_methods = methods.map do |method|
+          method['method'] = [profiled_object_name, method['method']].join
+          method
+        end
+        instrumented_methods.concat(_instrumented_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)
 
       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|
           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
         end
-
       end
 
       puts
@@ -95,15 +168,20 @@ module RuntimeProfiler
     end
 
     def print_instrumented_sql_calls
-      instrumented_sql_calls = sort(self.data['instrumentation']['instrumented_sql_calls'])
+      instrumented_sql_calls = data['instrumentation']['instrumented_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)
 
       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|
           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,18 +191,17 @@ 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
         end
-
       end
 
       puts
@@ -136,6 +213,7 @@ module RuntimeProfiler
 
     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['instrumentation']['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.0'.freeze
+  VERSION = '0.4.1'.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', '~> 10.0'
-  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.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Wilfrido T. Nuqui Jr.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-18 00:00:00.000000000 Z
+date: 2021-01-01 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: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        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
@@ -190,6 +205,7 @@ files:
 - lib/runtime_profiler/profiler.rb
 - lib/runtime_profiler/text_report.rb
 - lib/runtime_profiler/version.rb
+- rp_view_only_methods_full_details.png
 - runtime_profiler.gemspec
 homepage: http://www.github.com/wnuqui/runtime_profiler
 licenses:
@@ -210,8 +226,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Runtime Profiler for Rails Applications