runtime_profiler 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f0d303faf46e8b0eec88384965d29c5136390166
+  data.tar.gz: 1653ba57d2cbf4b10dd9c8da35310e2ec6d20f00
+SHA512:
+  metadata.gz: ecdf3e02b864efeec7f8dacc7b96c443c6baaa39a4931af40cb3d720d6519f5094b2f2f10cdb884cc3f3ecb305440b59f4dfe968df9aeb92e3900536fa8814b6
+  data.tar.gz: 26fe71304d4b511468385739f163033f9bc7ec3562168d844068aac47fcb4bd9c540ade25b7cf6dd5ebac05d8184965f740689f4f5d27ebde1eecd1cc1b48a65

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.DS_Store
+.ruby-version

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Wilfrido T. Nuqui Jr.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+# runtime_profiler - Runtime Profiler for Rails Applications
+
+`runtime_profiler` instruments api or a method of your Rails application using Rails' `ActiveSupport::Notifications`
+
+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:
+
+```ruby
+group :development, :test do
+  ... ...
+  gem 'runtime_profiler'
+end
+```
+
+And then execute:
+
+    $ bundle
+
+## 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.
+
+Example:
+```ruby
+it 'updates user' do
+  RuntimeProfiler.profile!('updates user', [User]) {
+    patch :update, { id: user.id, name: 'Joe' }
+  }
+
+  expect(response.status).to eq(200)
+end
+```
+
+Run tests as usual and follow printed instructions after running tests.
+
+## Reporting
+
+To see profiling/instrumenting report, please 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
+```
+
+## Configurations
+
+All the configurable variables and their defaults are listed below:
+```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)
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/wnuqui/runtime_profiler. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## Acknowledgement
+
+Part of this profiler is based from https://github.com/steventen/sql_tracker.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'runtime_profiler'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require 'pry'
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/runtime_profiler

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require_relative '../lib/runtime_profiler/cli'
+
+cli = RuntimeProfiler::CLI.new
+cli.run

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/runtime_profiler.rb

@@ -0,0 +1,57 @@
+require 'active_support'
+
+require 'runtime_profiler/profiler'
+require 'method_meter'
+
+module RuntimeProfiler
+  include ActiveSupport::Configurable
+
+  config_accessor :instrumented_constants do
+    []
+  end
+
+  config_accessor :instrumented_paths do
+    %w(app lib)
+  end
+
+  config_accessor :instrumented_sql_commands do
+    %w(SELECT INSERT UPDATE DELETE)
+  end
+
+  config_accessor :output_path do
+    if defined?(Rails) && Rails.respond_to?(:root)
+      File.join(Rails.root.to_s, 'tmp')
+    else
+      'tmp'
+    end
+  end
+
+  class << self
+    def configure
+      Rails.application.eager_load! rescue nil
+      yield self if block_given?
+    end
+
+    def profile!(key, konstants)
+      konstants = konstants.is_a?(Array) ? konstants : [konstants]
+      profiler = Profiler.new(konstants)
+      profiler.prepare_for_instrumentation
+
+      MethodMeter.measure!(key) { yield }
+
+      profiler.save_instrumentation_data
+    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/callbacks/action_controller.rb

@@ -0,0 +1,36 @@
+require 'runtime_profiler/events/process_action_event'
+
+module RuntimeProfiler
+  module Callback
+    class ActionController
+      attr_reader :data
+
+      def initialize
+        @data = {}
+      end
+
+      def call(*args)
+        event = RuntimeProfiler::ProcessActionEvent.new(args: args)
+        return unless event.recordable?
+        add event
+      end
+
+      def controller_data
+        data.values.first
+      end
+
+      private
+
+      def add(event)
+        key = event.key
+        @data[key] = {}
+
+        @data[key][:path]           = event.path
+        @data[key][:total_runtime]  = event.total_runtime
+        @data[key][:db_runtime]     = event.db_runtime
+        @data[key][:view_runtime]   = event.view_runtime
+        @data[key][:payload]        = event.payload
+      end
+    end
+  end
+end

data/lib/runtime_profiler/callbacks/active_record.rb

@@ -0,0 +1,38 @@
+require 'runtime_profiler/events/sql_event'
+
+module RuntimeProfiler
+  module Callback
+    class ActiveRecord
+      attr_reader :data
+
+      def initialize
+        @data = {}
+      end
+
+      def call(*args)
+        event = RuntimeProfiler::SqlEvent.new(args: args, trace: caller)
+
+        return unless event.recordable?
+        return if event.trace.empty?
+
+        @data.key?(event.key) ? update(event) : add(event)
+      end
+
+      private
+
+      def add(event)
+        key = event.key
+        @data[key] = {}
+
+        @data[key][:sql]      = event.sanitized_sql
+        @data[key][:runtimes] = [
+          [ event.total_runtime, event.trace.first ]
+        ]
+      end
+
+      def update(event)
+        @data[event.key][:runtimes] << [ event.total_runtime, event.trace.first ]
+      end
+    end
+  end
+end

data/lib/runtime_profiler/cli.rb

@@ -0,0 +1,47 @@
+require 'commander'
+require 'json'
+
+require_relative 'text_report'
+
+module RuntimeProfiler
+  class CLI
+    include Commander::Methods
+
+    def run
+      program :name, 'runtime_profiler'
+      program :version, '0.1.0'
+      program :description, 'Display report in console given the JSON report file.'
+
+      command :view do |c|
+        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.action do |args, options|
+          default_options = {
+            sort_by: 'total_calls',
+            details: 'summary',
+            runtime_above: 0,
+            only_sqls: false,
+            only_methods: false,
+            calls_above: 1
+          }
+
+          options.default default_options
+
+          report = RuntimeProfiler::TextReport.new(args.first, options)
+
+          report.print
+        end
+      end
+
+      run!
+    end
+  end
+end

data/lib/runtime_profiler/events/process_action_event.rb

@@ -0,0 +1,33 @@
+module RuntimeProfiler
+  class ProcessActionEvent
+    attr_reader :started_at, :finished_at, :payload
+
+    def initialize(args:)
+      _name, @started_at, @finished_at, _unique_id, @payload = args
+    end
+
+    def total_runtime
+      1000.0 * (@finished_at - @started_at)
+    end
+
+    def view_runtime
+      @view_runtime ||= @payload[:view_runtime]
+    end
+
+    def db_runtime
+      @db_runtime ||= @payload[:db_runtime]
+    end
+
+    def recordable?
+      true  # NB: We may be putting login on this in the future
+    end
+
+    def path
+      @path ||= @payload[:path].gsub(/(\S=)(?:(?!&).)+/, '\1xxx').gsub(/(\d+)/, 'xxx')
+    end
+
+    def key
+      @key ||= Digest::MD5.hexdigest(path.downcase)
+    end
+  end
+end

data/lib/runtime_profiler/events/sql_event.rb

@@ -0,0 +1,69 @@
+module RuntimeProfiler
+  class SqlEvent
+    attr_reader :started_at, :finished_at, :payload, :trace
+
+    def initialize(args: , trace: )
+      _name, @started_at, @finished_at, _unique_id, @payload = args
+      @trace = sanitize_trace!(trace)
+    end
+
+    def recordable?
+      return true unless RuntimeProfiler.instrumented_sql_commands.respond_to?(:join)
+      instrumented_sql_matcher =~ sql
+    end
+
+    def total_runtime
+      1000.0 * (@finished_at - @started_at)
+    end
+
+    def sanitized_sql
+      sql.squish!
+
+      sql.gsub!(/(\s(=|>|<|>=|<=|<>|!=)\s)('[^']+'|[\$\+\-\w\.]+)/, '\1xxx')
+      sql.gsub!(/(\sIN\s)\([^\(\)]+\)/i, '\1(xxx)')
+      sql.gsub!(/(\sBETWEEN\s)('[^']+'|[\+\-\w\.]+)(\sAND\s)('[^']+'|[\+\-\w\.]+)/i, '\1xxx\3xxx')
+      sql.gsub!(/(\sVALUES\s)\(.+\)/i, '\1(xxx)')
+      sql.gsub!(/(\s(LIKE|ILIKE|SIMILAR TO|NOT SIMILAR TO)\s)('[^']+')/i, '\1xxx')
+      sql.gsub!(/(\s(LIMIT|OFFSET)\s)(\d+)/i, '\1xxx')
+
+      sql
+    end
+
+    def key
+      @key ||= Digest::MD5.hexdigest(sql.downcase)
+    end
+
+    private
+
+    def sql
+      @sql ||= @payload[:sql].dup
+    end
+
+    def instrumented_sql_matcher
+      @instrumented_sql_matcher ||= /\A#{RuntimeProfiler.instrumented_sql_commands.join('|')}/i
+    end
+
+    def trace_path_matcher
+      @trace_path_matcher ||= %r{^(#{RuntimeProfiler.instrumented_paths.join('|')})\/}
+    end
+
+    def sanitize_trace!(trace)
+      return trace unless defined?(Rails)
+      return trace unless Rails.respond_to?(:backtrace_cleaner)
+
+      if Rails.backtrace_cleaner.instance_variable_get(:@root) == '/'
+        Rails.backtrace_cleaner.instance_variable_set :@root, Rails.root.to_s
+      end
+
+      Rails.backtrace_cleaner.remove_silencers!
+
+      if RuntimeProfiler.instrumented_paths.respond_to?(:join)
+        Rails.backtrace_cleaner.add_silencer do |line|
+          line !~ trace_path_matcher
+        end
+      end
+
+      Rails.backtrace_cleaner.clean(trace)
+    end
+  end
+end

data/lib/runtime_profiler/instrumentation_data.rb

@@ -0,0 +1,171 @@
+module RuntimeProfiler
+  class InstrumentationData
+    attr_reader :controller_data, :sql_data
+
+    def initialize(controller_data: nil, sql_data: nil)
+      @controller_data = controller_data
+      @sql_data = sql_data
+    end
+
+    def persist!
+      instrumented_api = [controller_data[:payload][:controller], controller_data[:payload][:action]].join('#')
+
+      instrumentation_data = {
+        instrumentation: {
+          instrumented_api: instrumented_api,
+          summary: {
+                        db_runtime: controller_data[:db_runtime],
+                      view_runtime: controller_data[:view_runtime],
+                     total_runtime: controller_data[:total_runtime],
+                       slowest_sql: sql_calls_data[:slowest_sql],
+                 mostly_called_sql: sql_calls_data[:mostly_called_sql],
+                   total_sql_calls: sql_calls_data[:total_sql_calls],
+            total_unique_sql_calls: sql_calls_data[:total_unique_sql_calls],
+                    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
+        }
+      }
+
+      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 = {}
+
+        # TODO: Group methods under a key and under an object
+        MethodMeter.measurement.each do |measurement|
+          measurement.each_pair do |key, data|
+            data.each do |d|
+              object = d[:method].split(separator = '.')
+              object = d[:method].split(separator = '#') if object.length == 1
+
+              d[:method] = separator + object.second
+
+              if instrumented_methods[object.first]
+                instrumented_methods[object.first] << d
+              else
+                instrumented_methods[object.first] = [d]
+              end
+            end
+          end
+        end
+
+        instrumented_methods = instrumented_methods.inject({}) do |hash, (key, value)|
+          val = value.sort { |a, b| b[:total_runtime] <=> a[:total_runtime] }
+          hash[key] = val
+          hash
+        end
+
+        slowest_method = {total_runtime: 0}
+        mostly_called_method = {total_calls: 0}
+
+        instrumented_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]
+
+          if slowest[:total_runtime] > slowest_method[:total_runtime]
+            slowest_method[:method]         = [profiled_object_name, slowest[:method]].join
+            slowest_method[:total_runtime]  = slowest[:total_runtime]
+          end
+
+          # sort using `total_calls` in DESC order and GET first item
+          mostly_called = methods.sort { |a, b| b[:total_calls] <=> a[:total_calls] } [0]
+
+          if mostly_called[:total_calls] > mostly_called_method[:total_calls]
+            mostly_called_method[:method]         = [profiled_object_name, mostly_called[:method]].join
+            mostly_called_method[:total_runtime]  = mostly_called[:total_runtime]
+            mostly_called_method[:total_calls]    = mostly_called[:total_calls]
+            mostly_called_method[:min]            = mostly_called[:min]
+            mostly_called_method[:max]            = mostly_called[:max]
+          end
+        end
+
+        {
+          instrumented_methods: instrumented_methods,
+                slowest_method: slowest_method,
+          mostly_called_method: mostly_called_method
+        }
+      end
+    end
+
+    def sql_calls_data
+      @sql_calls_data ||= begin
+        instrumented_sql_calls = []
+
+        slowest_sql = {total_runtime: 0}
+        mostly_called_sql = {total_calls: 0}
+
+        sql_data.values.each do |value|
+          total_calls   = value[:runtimes].size
+          total_runtime = value[:runtimes].map { |runtime| runtime[0] }.reduce(:+)
+          average       = total_runtime / total_calls
+
+          # sort using `runtimes` in DESC order
+          runtimes = value[:runtimes].sort { |a, b| b[0] <=> a[0] }
+          slowest = runtimes[0]
+          fastest = runtimes[runtimes.size - 1]
+
+          if slowest[0] > slowest_sql[:total_runtime]
+            slowest_sql[:sql]           = value[:sql]
+            slowest_sql[:total_runtime] = slowest[0]
+            slowest_sql[:source]        = slowest[1]
+          end
+
+          instrumented_sql_calls << {
+                      sql: value[:sql],
+                 runtimes: runtimes,
+              total_calls: total_calls,
+            total_runtime: total_runtime,
+                  average: average,
+                      min: fastest[0],
+                      max: slowest[0]
+          }
+
+          if total_calls > mostly_called_sql[:total_calls]
+            mostly_called_sql[:sql]           = value[:sql]
+            mostly_called_sql[:runtimes]      = value[:runtimes]
+            mostly_called_sql[:total_calls]   = total_calls
+            mostly_called_sql[:total_runtime] = total_runtime
+            mostly_called_sql[:average]       = average
+            mostly_called_sql[:min]           = fastest[0]
+            mostly_called_sql[:max]           = slowest[0]
+          end
+        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,
+                     slowest_sql: slowest_sql,
+               mostly_called_sql: mostly_called_sql
+        }
+      end
+    end
+  end
+end

data/lib/runtime_profiler/profiler.rb

@@ -0,0 +1,55 @@
+# require 'method_profiler'
+
+require 'runtime_profiler/callbacks/active_record'
+require 'runtime_profiler/callbacks/action_controller'
+require 'runtime_profiler/instrumentation_data'
+
+module RuntimeProfiler
+  class Profiler
+    attr_accessor :instrumented_constants
+
+    def initialize(konstants)
+      self.instrumented_constants = konstants
+    end
+
+    def prepare_for_instrumentation
+      subscribe_to_event_notifications
+      prepare_methods_to_instrument
+    end
+
+    def subscribe_to_event_notifications
+      @subscribers = []
+
+      @active_record_callback = Callback::ActiveRecord.new
+
+      @subscribers << ActiveSupport::Notifications
+        .subscribe('sql.active_record', @active_record_callback)
+
+      @action_controller_callback = Callback::ActionController.new
+
+      @subscribers << ActiveSupport::Notifications
+        .subscribe('process_action.action_controller', @action_controller_callback)
+    end
+
+    def unsubscribe_to_event_notifications
+      @subscribers.each do |subscriber|
+        ActiveSupport::Notifications.unsubscribe(subscriber)
+      end
+    end
+
+    def prepare_methods_to_instrument
+      self.instrumented_constants.flatten
+        .each { |constant| MethodMeter.observe(constant) }
+    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
+
+      instrumentation_data.persist!
+    end
+  end
+end

data/lib/runtime_profiler/text_report.rb

@@ -0,0 +1,194 @@
+require 'hirb'
+require 'terminal-table'
+require 'active_support/core_ext/string'
+
+module RuntimeProfiler
+  class TextReport
+    COUNT_WIDTH         = 5
+    DURATION_WIDTH      = 22
+    TOTAL_RUNTIME_WIDTH = 20
+
+    SUMMARY_TEMPLATE = <<-EOT.strip_heredoc
+
+        \e[1mPROFILING REPORT\e[22m
+        ----------------
+
+        \e[1mRUNTIME\e[22m
+          Total Runtime     : %s ms
+          Database Runtime  : %s ms
+          View Runtime      : %s ms
+
+        \e[1mMETHODS\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
+
+    attr_accessor :data, :options
+
+    def initialize(json_file, 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
+      end
+    end
+
+    private
+
+    def print_summary
+      summary = SUMMARY_TEMPLATE % summary_template_data
+      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}
+      end
+
+      instrumented_methods = sort(instrumented_methods)
+
+      table = Terminal::Table.new do |t|
+        t.headings = ['Method', 'Total Runtime (ms)', 'Total Calls', 'Min', 'Max']
+
+        instrumented_methods.each_with_index do |row, index|
+          t.add_row [
+            row['method'],
+            row['total_runtime'],
+            row['total_calls'],
+            row['min'],
+            row['max']
+          ]
+          t.add_separator if index < instrumented_methods.size - 1
+        end
+
+      end
+
+      puts
+      puts
+      puts "\e[1mINSTRUMENTED METHOD(s)\e[22m"
+      puts
+      puts table
+    end
+
+    def print_instrumented_sql_calls
+      instrumented_sql_calls = sort(self.data['instrumentation']['instrumented_sql_calls'])
+
+      table = Terminal::Table.new do |t|
+        t.headings = ['Count', 'Total Runtime (ms)', 'Average Runtime (ms)', 'SQL Query', '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)
+          total_lines       = if chopped_sql.length >= source_list.length
+                                chopped_sql.length
+                              else
+                                source_list.length
+                              end
+
+          (0...total_lines).each do |line|
+            count         = line == 0                 ? row['total_calls']    : ''
+            average       = line == 0                 ? average_runtime       : ''
+            total_runtime = line == 0                 ? row['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
+
+      end
+
+      puts
+      puts
+      puts "\e[1mINSTRUMENTED SQL(s)\e[22m"
+      puts
+      puts table
+    end
+
+    def wrap_text(text, width)
+      return [text] if text.length <= width
+      text.scan(/.{1,#{width}}/)
+    end
+
+    def wrap_list(list, width)
+      list.map do |text|
+        wrap_text(text, width)
+      end.flatten
+    end
+
+    def sql_width
+      @sql_width ||= begin
+        terminal_width = Hirb::Util.detect_terminal_size.first
+        (terminal_width - COUNT_WIDTH - DURATION_WIDTH - TOTAL_RUNTIME_WIDTH) / 2
+      end
+    end
+
+    def sort(data)
+      data.sort_by do |d|
+        if self.options.sort_by == 'total_runtime'
+          -d['total_runtime']
+        else
+          -d['total_calls']
+        end
+      end
+    end
+
+    def summary_template_data
+      summary = self.data['instrumentation']['summary']
+
+      [
+        summary['total_runtime'].round(2),
+        summary['db_runtime'].round(2),
+        summary['view_runtime'].round(2),
+
+        summary['slowest_method']['method'],
+        summary['slowest_method']['total_runtime'].round(2),
+
+        summary['mostly_called_method']['method'],
+        summary['mostly_called_method']['total_calls'],
+        summary['mostly_called_method']['total_runtime'].round(2),
+
+        summary['total_sql_calls'],
+        summary['total_unique_sql_calls'],
+
+        summary['slowest_sql']['total_runtime'].round(2),
+        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']['sql'],
+        summary['mostly_called_sql']['runtimes'].map { |runtime| runtime[1] }.uniq
+      ]
+    end
+  end
+end

data/lib/runtime_profiler/version.rb

@@ -0,0 +1,3 @@
+module RuntimeProfiler
+  VERSION = '0.1.0'.freeze
+end

data/runtime_profiler.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'runtime_profiler/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'runtime_profiler'
+  spec.version       = RuntimeProfiler::VERSION
+  spec.authors       = ['Wilfrido T. Nuqui Jr.']
+  spec.email         = ['nuqui.dev@gmail.com']
+
+  spec.summary       = 'Runtime Profiler for Rails Applications'
+  spec.description   = 'Runtime Profiler for Rails Applications'
+  spec.homepage      = 'http://www.github.com/wnuqui/runtime_profiler'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'bin'
+  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 'minitest-line'
+  spec.add_runtime_dependency 'terminal-table'
+  spec.add_runtime_dependency 'commander'
+  spec.add_runtime_dependency 'hirb'
+  spec.add_runtime_dependency 'method_meter'
+  spec.add_runtime_dependency 'defined_methods'
+end

metadata

@@ -0,0 +1,218 @@
+--- !ruby/object:Gem::Specification
+name: runtime_profiler
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wilfrido T. Nuqui Jr.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-18 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'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-line
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: commander
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hirb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: method_meter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: defined_methods
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Runtime Profiler for Rails Applications
+email:
+- nuqui.dev@gmail.com
+executables:
+- runtime_profiler
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/runtime_profiler
+- bin/setup
+- lib/runtime_profiler.rb
+- lib/runtime_profiler/callbacks/action_controller.rb
+- lib/runtime_profiler/callbacks/active_record.rb
+- lib/runtime_profiler/cli.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
+- runtime_profiler.gemspec
+homepage: http://www.github.com/wnuqui/runtime_profiler
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Runtime Profiler for Rails Applications
+test_files: []