runtime_profiler 0.1.4 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e33ac72fec2841f6fb3c5b50ae46aece8bd6902ff177392dfc056e7f6ae336d6
-  data.tar.gz: 1053411fdb7d59d1c54f9c89cd1f465dbf8cc1b280bf9d42a93ee5055fc223bf
+  metadata.gz: 7839cd9d608c73c35a269e4bf7f2f52ae482e714dd99a108e9078e6628f9a86b
+  data.tar.gz: 9eecf865436dcd07b575d96c1bfb21d1ba1c9344c9100aa955ed00a84d2e8011
 SHA512:
-  metadata.gz: 430be7e054bd7748c36bf468bf28d134d35a43a441d5d3fff6730e29d15d173a74ce5e64b8e3711ff63291b10dc8c3977f58a3caecff6c649936f632d7b15be7
-  data.tar.gz: b2d7f4f5019f489def998d8858bbec09c99be054289429482858836a0e88a2e49e22626e2f31461cedf4e9f5473eafb8baac4e0818528c2aec04a824d68683d7
+  metadata.gz: eaeedf57a5c02b27e1f75778290f821a4b0ed3901220c7dce8529df44d4bf49fe8d0846a4bb3e7e73b485c96196f85d7d57a6cc3e8df93bfda8b05676526ddc1
+  data.tar.gz: 196e71a0244d7d47c8af6585213c45373dcc8d694bac70daa86e9688877d4b02fc029bc50df87baf3ce288e64c8c7850ea717603975eb38a9da367e34998d9a5

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,13 +1,9 @@
-# runtime_profiler - Runtime Profiler for Rails Applications
+# 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` instruments api or a method of your Rails application using Rails' `ActiveSupport::Notifications`
+`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.
 
 It then aggregates and generates report to give you insights about specific calls in your Rails application.
 
-## Note
-
-This is still a **work in progress**. However, this is a tool meant to be used in development so it is safe to use.
-
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -25,9 +21,9 @@ And then execute:
 
 ## Profiling/Instrumenting
 
-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.
+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.
 
-Example:
+Example of a test code wrap by `RuntimeProfiler.profile!` method:
 ```ruby
 it 'updates user' do
   RuntimeProfiler.profile!('updates user', [User]) {
@@ -38,19 +34,72 @@ 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.
 
-## Reporting
+If you prefer writing just code snippet, then just wrap the snippet with `RuntimeProfiler.profile!` method:
+```ruby
+RuntimeProfiler.profile!('UserMailer', [UserMailer]) {
+  user = User.last
+  UserMailer.with(user: user).weekly_summary.deliver_now
+}
+```
 
-To see profiling/instrumenting report, please open the report in browser with JSON viewer report. Or you can run the following command:
+**Note:** The code (tests or not) where `RuntimeProfiler.profile!` is used must be **free from any mocking** since your goal is to check bottlenecks.
+
+## 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:
 
 ```bash
 bundle exec runtime_profiler view ~/the-rails-app/tmp/runtime-profiling-51079-1521371428.json
 ```
 
+### view options
+
+Here are the command line options for `runtime_profiler view` command.
+
+```bash
+$ 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
 
-All the configurable variables and their defaults are listed below:
+All the configurable variables and their defaults are listed below. These configurations can be put in the `config/initializers` folder of your Rails application.
 ```ruby
 RuntimeProfiler.output_path = File.join(Rails.root.to_s, 'tmp')
 RuntimeProfiler.instrumented_constants = [User]

data/lib/runtime_profiler.rb

@@ -41,17 +41,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

data/lib/runtime_profiler/cli.rb

@@ -16,28 +16,33 @@ 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
 

data/lib/runtime_profiler/instrumentation_data.rb

@@ -3,12 +3,15 @@ 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('#')
+      instrumented_api = [
+        controller_data[:payload][:controller],
+        controller_data[:payload][:action]
+      ].join('#') if controller_data[:payload]
 
       instrumentation_data = {
         instrumentation: {
@@ -38,7 +41,8 @@ module RuntimeProfiler
         f.write JSON.dump(instrumentation_data)
       end
 
-      puts '~~~~> [ Profiling RUNTIME ] Profiling now COMPLETE and JSON report written at ' + output_file.to_s
+      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 ]'

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,17 +9,17 @@ 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)
 
@@ -39,48 +40,121 @@ module RuntimeProfiler
 
       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
+            SQL             : %s
+            Sources         : %s
+
+      EOT
+
     attr_accessor :data, :options
 
     def initialize(json_file, options)
       self.data = JSON.parse( File.read(json_file) )
-      self.options  = options
+      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
@@ -95,7 +169,11 @@ 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']
@@ -103,7 +181,8 @@ module RuntimeProfiler
         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,14 +192,14 @@ 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]
           end
-          
+
           t.add_row []
           t.add_separator if index < instrumented_sql_calls.size - 1
         end
@@ -152,43 +231,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
 
-      [
-        summary['total_runtime'].round(2),
-        summary['db_runtime'].round(2),
-        summary['view_runtime'].round(2),
+    def calls_above(data)
+      data.select { |d| d['total_calls'] > options.calls_above }
+    end
+
+    def details_template_data
+      summary = data['instrumentation']['summary']
+
+      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.3.0'.freeze
 end

data/runtime_profiler.gemspec

@@ -19,7 +19,7 @@ Gem::Specification.new do |spec|
   spec.executables   = ['runtime_profiler']
   spec.require_paths = ['lib']
 
-  spec.add_development_dependency 'bundler', '~> 1.12'
+  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'

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: runtime_profiler
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Wilfrido T. Nuqui Jr.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-14 00:00:00.000000000 Z
+date: 2020-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -173,6 +173,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".semaphore/semaphore.yml"
 - Gemfile
 - LICENSE.txt
 - README.md