rbenchmarker 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2877e9a63034a510f81700591df732ac237b2f7f30e7a09ac34edee5d2315faf
+  data.tar.gz: 282590fe246b95a914dd91e3bafb9985b3cd9877d29272373af2790b389391d3
+SHA512:
+  metadata.gz: 3e06e196167f76bb8a9bfef4e55bf81f02779fe3b842e969518dbb2df0978b216b0001b0567aa3595bc5a2ae15f22fc577429e6462c3c418fdaf99216d5c2c40
+  data.tar.gz: 7a9178fa2069857b395f3c92d3768b3ff08176c82d2dc3a43007df73220dd91fb460d639c593b940c3712efa6aa953f4753a0ed4fb78c3b11b7ad413e5b8342c

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Rbenchmarker Changelog
+
+Doing our best at supporting [SemVer](http://semver.org/) with a nice looking [Changelog](http://keepachangelog.com).
+
+## Version 0.1.1 <sub><sup>2021-02-05</sub></sup>
+
+- Corrected incorrect description
+
+## Version 0.1.0 <sub><sup>2020-02-05</sub></sup>
+
+- Initial version
+- Class methods benchmark
+- Module methods benchmark
+- Options to select the target
+- Options to choose where to place the logs
+- Benchmark option to select the number of executions
+- Option to select dry run

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 daiki shibata
+
+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,364 @@
+# Rbenchmarker
+
+Rbenchmarker is a gem that allows you to automatically benchmark the execution time of a method defined in a Ruby class and module.
+Benchmark module (https://docs.ruby-lang.org/ja/latest/class/Benchmark.html) is used inside Rbenchmarker, and bm method is automatically applied to all target methods.
+
+However, ｍethod itself to which Rbenchmarker is applied remains unchanged, takes the same arguments as before, and returns the same return value as before.
+
+So you don't have to change the methods yourself, and you don't have to benchmark the methods one by one.
+Just launch the application as before and will automatically benchmark all targeted methods!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+# Gemfile
+
+gem 'rbenchmarker'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install rbenchmarker
+
+## Add the launch process to your Ruby project
+
+Add the following code to any file in your Ruby project.
+
+```ruby
+# Note that you need to run `Rbenchmarker.setup` after all the files have been read.
+Rbenchmarker.setup switch: 'on',
+                   output_log_path: nil,
+                   except_classes: [],
+                   except_modules: []
+```
+
+Or run it directly from console
+
+```
+irb(main):001:0> Rbenchmarker.setup switch: 'on', output_log_path: nil, except_classes: [], except_modules: []
+=> true
+```
+
+ The `setup` method executes the process of adding the benchmark function to all the methods in the specified class and module.
+
+Note that you need to run `Rbenchmarker.setup` after all the files (classes, modules) have been read.
+
+[Details of setup options](https://github.com/shibatadaiki/Rbenchmarker#about-setup-options)
+
+### For Ruby on Rails projects, add the following settings to your `config`
+
+```ruby
+# config/environments/development.rb
+
+config.eager_load = true # Please note that this setting is mandatory!
+
+config.after_initialize do
+  Rbenchmarker.setup switch: 'on', output_log_path: nil, except_classes: [], except_modules: []
+end
+```
+
+Please note that when using the Rbenchmark feature, the server will need to be restarted for the file changes to take effect.
+
+[Details of config.after_initialize and config.eager_load](https://guides.rubyonrails.org/configuring.html#rails-general-configuration)
+
+## Add rbenchmarker to your Class
+
+```ruby
+# app/models/sample_class.rb
+
+class SampleClass
+  rbenchmarker all: __FILE__
+end
+```
+
+Your Class is now a benchmarker!
+
+When the method in the class in which rbenchmarker is set is executed, the following log will be output.
+
+Logs are placed directly under the './log' directory if './log' directory exists, or directly under the current directory if does not exist.
+
+`rbenchmarker.log`
+
+```log
+# Logfile created on 2020-12-22 16:24:06 +0900 by logger.rb/v1.4.2
+I, [2020-12-22T16:24:06.327445 #54558]  INFO -- : == Start recording Rbenchmarker == 
+
+I, [2020-12-22T16:24:12.848277 #54558]  INFO -- : 
+report def test_method1 class method: current time
+user: 0.00000900, system: 0.00000700, total: 0.00001600, real: 0.00000700
+report def test_method1 class method: total time for 1 times called
+user: 0.00000900, system: 0.00000700, total: 0.00001600, real: 0.00000700
+report def test_method1 class method: avarage time
+user: 0.00000900, system: 0.00000700, total: 0.00001600, real: 0.00000700
+
+I, [2020-12-22T16:24:14.009972 #54558]  INFO -- : 
+report def test_method1 class method: current time
+user: 0.00000500, system: 0.00000200, total: 0.00000700, real: 0.00000400
+report def test_method1 class method: total time for 2 times called
+user: 0.00001400, system: 0.00000900, total: 0.00002300, real: 0.00001100
+report def test_method1 class method: avarage time
+user: 0.00000700, system: 0.00000450, total: 0.00001150, real: 0.00000550
+
+I, [2020-12-22T16:24:29.969068 #54558]  INFO -- : 
+report def test_method2 instance method: current time
+user: 0.00000600, system: 0.00000200, total: 0.00000800, real: 0.00000500
+report def test_method2 instance method: total time for 1 times called
+user: 0.00000600, system: 0.00000200, total: 0.00000800, real: 0.00000500
+report def test_method2 instance method: avarage time
+user: 0.00000600, system: 0.00000200, total: 0.00000800, real: 0.00000500
+
+I, [2020-12-22T16:24:30.545224 #54558]  INFO -- : 
+report def test_method2 instance method: current time
+user: 0.00000600, system: 0.00000200, total: 0.00000800, real: 0.00000500
+report def test_method2 instance method: total time for 2 times called
+user: 0.00001200, system: 0.00000400, total: 0.00001600, real: 0.00001000
+report def test_method2 instance method: avarage time
+user: 0.00000600, system: 0.00000200, total: 0.00000800, real: 0.00000500
+
+I, [2020-12-22T16:24:31.185216 #54558]  INFO -- : 
+report def test_method2 instance method: current time
+user: 0.00000600, system: 0.00000200, total: 0.00000800, real: 0.00000400
+report def test_method2 instance method: total time for 3 times called
+user: 0.00001800, system: 0.00000600, total: 0.00002400, real: 0.00001400
+report def test_method2 instance method: avarage time
+user: 0.00000600, system: 0.00000200, total: 0.00000800, real: 0.00000467
+```
+
+If repeat the same method, the total execution time and the average execution time of the number of executions will be output to the log.
+
+## Add rbenchmarker to your Module
+
+Can do the same with class as with module, but with module, additional work is required.
+
+```ruby
+# lib/sample_module.rb
+
+module SampleModule
+  extend Rbenchmarker::ClassMethods # for module, add this sentence before launching rbenchmarker
+  rbenchmarker all: __FILE__
+end
+```
+
+Then add the following options in the class that is using that module.
+
+```ruby
+# app/models/class_include_module.rb
+
+class ClassIncludeModule
+  include SampleModule
+  rbenchmarker all: __FILE__, include: [SampleModule] # In the `include` option, specify all included modules in array format
+end
+```
+
+```ruby
+# app/models/class_extend_module.rb
+
+class ClassExtendModule
+  extend SampleModule
+  rbenchmarker all: __FILE__, extend: [SampleModule] # In the `extend` option, specify all extended modules in array format
+end
+```
+
+```ruby
+# app/models/class_prepend_module.rb
+
+class ClassPrependModule
+  prepend SampleModule
+  rbenchmarker all: __FILE__, prepend: [SampleModule] # In the `prepend` option, specify all prepended modules in array format
+end
+```
+
+The same is true for modules that use modules.
+
+```ruby
+# lib/module_include_module.rb
+
+module DoIncludeModule
+  include SampleModule
+  extend Rbenchmarker::ClassMethods
+  rbenchmarker all: __FILE__, include: [SampleModule]
+end
+```
+
+```ruby
+# lib/module_extend_module.rb
+
+module DoExtendModule
+  extend SampleModule
+  extend Rbenchmarker::ClassMethods
+  rbenchmarker all: __FILE__, extend: [SampleModule]
+end
+```
+
+```ruby
+# lib/module_prepend_module.rb
+
+module DoPrependModule
+  prepend SampleModule
+  extend Rbenchmarker::ClassMethods
+  rbenchmarker all: __FILE__, prepend: [SampleModule]
+end
+```
+
+Your Module is now a benchmarker!
+
+## About `rbenchmarker` options
+
+List of all possible options
+
+| Options | Description | Exsample |
+| ------------- | ------------- | ------------- |
+| `all`  | `all` option performs static analysis to identify the target method, so put `__FILE__` in the argument. Setting this option will measure all methods listed in the file. normally, set this option. | `rbenchmarker all: __FILE__` |
+| `only` | method specified in `only` only will be benchmarked. | `rbenchmarker only: [:sample_method1, :sample_method2]` |
+| `except` | method specified in `except` will not be benchmarked. | `rbenchmarker except: [:sample_method1, :sample_method2]` |
+| `added` | method specified by `added` is added to the benchmark after the `only` and `except` method filtering is done. | `rbenchmarker added: [:sample_method1, :sample_method2]` |
+| `label_width` | `label_width` specifies the width of the benchmark label. | `rbenchmarker label_width: 25` |
+| `times` | benchmark is measured by repeatedly executing the benchmarked method for the number of times specified by `times`. (Keep in mind that code such as SQL queries will also be executed repeatedly.) | `rbenchmarker times: 5` |
+| `require_hidden_method` | If `require_hidden_method` option is set to true, methods dynamically created by metaprogramming, methods added to another file, etc. are also included. | `rbenchmarker require_hidden_method: true` |
+| `include` | in the `include` option, specify the module that you are including. Arrange the option array in the loading order of the modules to be included. | `rbenchmarker include: [SampleModule1, SampleModule2]` |
+| `extend` | in the `extend` option, specify the module that you are extending. Arrange the option array in the loading order of the modules to be extended. | `rbenchmarker extend: [SampleModule1, SampleModule2]` |
+| `prepend` | in the `prepend` option, specify the module that you are prepending. Arrange the option array in the loading order of the modules to be prepended. | `rbenchmarker prepend: [SampleModule1, SampleModule2]` |
+
+Can set multiple options as follows.
+
+```ruby
+# app/models/sample_class.rb
+
+class SampleClass
+   rbenchmarker all: __FILE__, only: [:sample_method1, :sample_method2], label_width: 25
+end
+```
+
+Of course, also possible with modules.
+
+```ruby
+# lib/sample_module.rb
+
+module SampleModule
+  extend Rbenchmarker::ClassMethods
+  rbenchmarker all: __FILE__, only: [:sample_method1, :sample_method2], label_width: 25
+end
+```
+
+## About `require_hidden_method` option
+
+Maybe, `require_hidden_method` option may often be used in Ruby on Rails projects.
+
+For example, in the case of the following Ruby on Rails code
+
+```ruby
+# app/models/sample_class.rb
+
+class SampleClass
+  rbenchmarker all: __FILE__
+
+  belongs_to :sample_parent
+  has_many :sample_children, dependent: :destroy
+  scope :has_sample_parent, -> { where.not(sample_parent_id: nil) }
+
+  def my_name_length
+    name.length
+  end
+end
+```
+
+Ruby on Rails adds methods to the class with various options, but usually it's not written in a file.
+However, the `all: __FILE__` option can only track methods defined directly in the file. (In this case, only `my_name_length` is tracked)
+
+In such cases, use the `require_hidden_method` option to track invisible methods.
+
+```ruby
+# app/models/sample_class.rb
+
+class SampleClass
+  rbenchmarker require_hidden_method: true # the `all` option is not required when using the `require_hidden_method` option
+
+  belongs_to :sample_parent
+  has_many :sample_children, dependent: :destroy
+  scope :has_sample_parent, -> { where.not(sample_parent_id: nil) }
+
+  def my_name_length
+    name.length
+  end
+end
+```
+
+The same applies in the following cases.
+
+```ruby
+# lib/module_include_module.rb
+
+module IncludedModule
+  extend ActiveSupport::Concern
+  included do
+    def sample_module_method
+     puts 'sample_module_method!'
+    end
+  end
+end
+
+# app/models/sample_class.rb
+
+class SampleClass
+  include IncludedModule
+  rbenchmarker require_hidden_method: true # Requires the `require_hidden_method` option to track the IncludedModule methods
+end
+```
+
+Set of `extend ActiveSupport::Concern` and `included do ~`, which is often seen when using Ruby on Rails modules, adds a method to the class itself by internally executing `class_eval` to the target class
+(Rather than using module methods).
+Therefore, want Rbenchmarker to track the methods added in this way, need the `require_hidden_method` option.
+
+However, `require_hidden_method` option can be annoying as it keeps track of all hidden methods. In that case, adjust using options such as `only`, `except`, and `added`.
+
+## About `setup` options
+
+| Options | Description | Exsample |
+| ------------- | ------------- | ------------- |
+| `switch`  | In case of `off` or `OFF`, the processing of rbenchmarker will not be executed. | `Rbenchmarker.setup switch: 'off'` |
+| `output_log_path` | Specify the output destination of the measurement result log output by rbenchmark. |  `Rbenchmarker.setup output_log_path: '/Users/daiki.shibata/xxx/workspace'` |
+| `except_classes` | Specify the class that does not give rbenchmark processing. | `Rbenchmarker.setup except_classes: [Class1, Class2, Class3]` |
+| `except_modules` | Specify the module that does not give rbenchmark processing. | `Rbenchmarker.setup except_modules: [Module1, Module2, Module3]` |
+
+Can set multiple options as follows.
+
+```ruby
+# rbenchmarker_setup.rb
+
+Rbenchmarker.setup switch: 'on',
+                   output_log_path: '/Users/daiki.shibata/xxx/workspace',
+                   except_classes: [Class1, Class2, Class3],
+                   except_modules: [Module1, Module2, Module3]
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Rbenchmarker project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/shibatadaiki/Rbenchmarker/blob/main/CODE_OF_CONDUCT.md).
+
+## Contributing
+
+Everyone is encouraged to help improve this project. Here are a few ways you can help:
+
+- [Report bugs](https://github.com/shibatadaiki/Rbenchmarker/issues)
+- Fix bugs and [submit pull requests](https://github.com/shibatadaiki/Rbenchmarker/pulls)
+- Write, clarify, or fix documentation
+- Suggest or add new features
+
+To get started with development:
+
+```sh
+git clone https://github.com/shibatadaiki/Rbenchmarker.git
+cd Rbenchmarker
+bundle install
+bundle exec rake test
+```

data/lib/rbenchmarker.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative 'rbenchmarker/version'
+require_relative 'rbenchmarker/class_methods'
+require_relative 'rbenchmarker/prepend_modules'
+require_relative 'rbenchmarker/rbenchmarker_log'
+require_relative 'rbenchmarker/exceptions'
+
+module Rbenchmarker
+  LOG_DIRECTORY = 'log'
+  LOG_FILE_NAME = 'rbenchmark.log'
+
+  @setup_executed = false
+  @rbench_classes = []
+  @rbench_modules = []
+  @object_with_has_modules = []
+  @module_with_has_methods_lists = {}
+  @bm_reports = {}
+  @rbenchmarker_log_file_path = if Dir.exist? "#{Dir.pwd}/#{LOG_DIRECTORY}"
+                                  "#{Dir.pwd}/#{LOG_DIRECTORY}/#{LOG_FILE_NAME}"
+                                else
+                                  "#{Dir.pwd}/#{LOG_FILE_NAME}"
+                                end
+
+  def self.setup_executed?
+    @setup_executed
+  end
+
+  def self.setup_executed!
+    @setup_executed = true
+  end
+
+  def self.setup_no_executed!
+    @setup_executed = false
+  end
+
+  def self.tracking_classes
+    @rbench_classes
+  end
+
+  def self.add_class(value)
+    @rbench_classes << value
+  end
+
+  def self.init_tracking_classes
+    @rbench_classes = []
+  end
+
+  def self.tracking_modules
+    @rbench_modules
+  end
+
+  def self.add_module(value)
+    @rbench_modules << value
+  end
+
+  def self.init_tracking_modules
+    @rbench_modules = []
+  end
+
+  def self.object_with_has_modules
+    @object_with_has_modules
+  end
+
+  def self.add_object_with_modules(value)
+    @object_with_has_modules << value
+  end
+
+  def self.init_object_with_has_modules
+    @object_with_has_modules = []
+  end
+
+  def self.module_with_has_methods_lists
+    @module_with_has_methods_lists
+  end
+
+  def self.add_module_with_has_methods_list(key, value)
+    @module_with_has_methods_lists[key] = value
+  end
+
+  def self.init_module_with_has_methods_lists
+    @module_with_has_methods_lists = {}
+  end
+
+  def self.tracking_reports
+    @bm_reports
+  end
+
+  def self.add_report(key, value)
+    @bm_reports[key] = value
+    callbacks_self_add_report(key, value)
+  end
+
+  def self.init_tracking_reports
+    @bm_reports = {}
+  end
+
+  def self.output_log_file_path
+    @rbenchmarker_log_file_path
+  end
+
+  def self.change_output_log_file_path(path_text)
+    @rbenchmarker_log_file_path = path_text
+  end
+
+  def self.init_log_file_path
+    @rbenchmarker_log_file_path = if Dir.exist? "#{Dir.pwd}/#{LOG_DIRECTORY}"
+                                    "#{Dir.pwd}/#{LOG_DIRECTORY}/#{LOG_FILE_NAME}"
+                                  else
+                                    "#{Dir.pwd}/#{LOG_FILE_NAME}"
+                                  end
+  end
+
+  # This method must read (execute) after reading all files except this configuration file.
+  def self.setup(switch: 'on', output_log_path: nil, except_classes: [], except_modules: [])
+    return if %w[off OFF].include?(switch)
+    return puts 'setup has already been executed.' if setup_executed?
+
+    setup_validation_check(except_classes, except_modules, output_log_path)
+
+    change_output_log_file_path "#{output_log_path}/#{LOG_FILE_NAME}" if output_log_path
+
+    tracking_classes.each do |benchmark_target_class, options|
+      next if except_classes.include?(benchmark_target_class)
+
+      benchmark_target_class.call_register_rbenchmarker_methods(options)
+    end
+
+    tracking_modules.each do |benchmark_target_module, options|
+      next if except_modules.include?(benchmark_target_module)
+
+      benchmark_target_module.call_register_rbenchmarker_methods(options)
+    end
+
+    Rbenchmarker::PrependModules.register_rbenchmarker_methods_to_module(
+      object_with_has_modules, module_with_has_methods_lists, except_modules
+    )
+
+    Rbenchmarker::RbenchmarkerLog.init_log
+    setup_executed!
+  end
+
+  # private
+
+  def self.setup_validation_check(except_classes, except_modules, output_log_path)
+    raise ExceptClassDesignationError unless except_classes.is_a?(Array)
+    raise ExceptClassDesignationError unless except_classes.all? { |obj| obj.class.to_s == 'Class' }
+    raise ExceptModuleDesignationError unless except_modules.is_a?(Array)
+    raise ExceptModuleDesignationError unless except_modules.all? { |obj| obj.class.to_s == 'Module' }
+    raise TargetDirPathError if output_log_path && !Dir.exist?(output_log_path)
+  end
+
+  def self.callbacks_self_add_report(key, value)
+    Rbenchmarker::RbenchmarkerLog.puts_log(key, value)
+  end
+
+  private_class_method :setup_validation_check
+  private_class_method :callbacks_self_add_report
+end

data/lib/rbenchmarker/class_methods.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'exceptions'
+require_relative 'register_rbenchmarker_methods'
+
+module Rbenchmarker
+  def self.included(klass)
+    klass.extend ClassMethods
+  end
+
+  module ClassMethods
+    def rbenchmarker(**options)
+      rbenchmarker_validation_check(options)
+
+      options[:only] = options[:only].map(&:to_sym) if options[:only]
+      options[:except] = options[:except].map(&:to_sym) if options[:except]
+      options[:added] = options[:added].map(&:to_sym) if options[:added]
+
+      granted_modules = {}
+      granted_modules[:prepend] = options.delete(:prepend) if options[:prepend]
+      granted_modules[:include] = options.delete(:include) if options[:include]
+      granted_modules[:extend] = options.delete(:extend) if options[:extend]
+
+      if instance_of?(Module)
+        options[:object_type] = 'Module'
+        Rbenchmarker.add_module [self, options]
+      else
+        options[:object_type] = 'Class'
+        Rbenchmarker.add_class [self, options]
+      end
+
+      Rbenchmarker.add_object_with_modules([self, granted_modules])
+    end
+
+    def call_register_rbenchmarker_methods(options)
+      options[:target_obj] = self
+      Rbenchmarker::RegisterRbenchmarkerMethods.register_rbenchmarker_methods(**options)
+    end
+
+    private # not strictly concealed because can be called from unspecified object.
+
+    def rbenchmarker_validation_check(options)
+      raise Rbenchmarker::TargetFilePathError if options[:all] && !options[:all].is_a?(String)
+      raise Rbenchmarker::TargetFilePathError if options[:all] && !File.file?(options[:all])
+      raise Rbenchmarker::OnlyMethodDesignationError if options[:only] && !options[:only].is_a?(Array)
+      raise Rbenchmarker::OnlyMethodDesignationError if options[:only] && !options[:only].all? do |method_name|
+        method_name.is_a?(String) || method_name.is_a?(Symbol)
+      end
+      raise Rbenchmarker::ExceptMethodDesignationError if options[:except] && !options[:except].is_a?(Array)
+      raise Rbenchmarker::ExceptMethodDesignationError if options[:except] && !options[:except].all? do |method_name|
+        method_name.is_a?(String) || method_name.is_a?(Symbol)
+      end
+      raise Rbenchmarker::AddedMethodDesignationError if options[:added] && !options[:added].is_a?(Array)
+      raise Rbenchmarker::AddedMethodDesignationError if options[:added] && !options[:added].all? do |method_name|
+        method_name.is_a?(String) || method_name.is_a?(Symbol)
+      end
+      raise Rbenchmarker::PrependModuleDesignationError if options[:prepend] && !options[:prepend].is_a?(Array)
+      raise Rbenchmarker::PrependModuleDesignationError if options[:prepend] && !options[:prepend].all? do |obj|
+        obj.class.to_s == 'Module'
+      end
+      raise Rbenchmarker::IncludeModuleDesignationError if options[:include] && !options[:include].is_a?(Array)
+      raise Rbenchmarker::IncludeModuleDesignationError if options[:include] && !options[:include].all? do |obj|
+        obj.class.to_s == 'Module'
+      end
+      raise Rbenchmarker::ExtendModuleDesignationError if options[:extend] && !options[:extend].is_a?(Array)
+      raise Rbenchmarker::ExtendModuleDesignationError if options[:extend] && !options[:extend].all? do |obj|
+        obj.class.to_s == 'Module'
+      end
+    end
+  end
+end
+
+Object.send :include, Rbenchmarker::ClassMethods

data/lib/rbenchmarker/exceptions.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Rbenchmarker
+  class ExceptClassDesignationError < ArgumentError
+    def initialize
+      super('"except_classes" option must be an array containing only "Class".')
+    end
+  end
+
+  class ExceptModuleDesignationError < ArgumentError
+    def initialize
+      super('"except_modules" option must be an array containing only the defined "Module".')
+    end
+  end
+
+  class TargetDirPathError < ArgumentError
+    def initialize
+      super('In the argument of "output_log_file_path", specify the path of the directory where you want to place the log.')
+    end
+  end
+
+  class OnlyMethodDesignationError < ArgumentError
+    def initialize
+      super('"Only" option must be an array containing only "String" or "Symbol".')
+    end
+  end
+
+  class ExceptMethodDesignationError < ArgumentError
+    def initialize
+      super('"Except" option must be an array containing only "String" or "Symbol".')
+    end
+  end
+
+  class AddedMethodDesignationError < ArgumentError
+    def initialize
+      super('"Added" option must be an array containing only "String" or "Symbol".')
+    end
+  end
+
+  class PrependModuleDesignationError < ArgumentError
+    def initialize
+      super('"prepend" option must be an array containing only the defined "Module".')
+    end
+  end
+
+  class IncludeModuleDesignationError < ArgumentError
+    def initialize
+      super('"include" option must be an array containing only the defined "Module".')
+    end
+  end
+
+  class ExtendModuleDesignationError < ArgumentError
+    def initialize
+      super('"extend" option must be an array containing only the defined "Module".')
+    end
+  end
+
+  class TargetFilePathError < ArgumentError
+    def initialize
+      super('Must be specify an existing file path. Unless there is a special reason, specify the return value of the "__FILE__" method in the all argument.')
+    end
+  end
+end

data/lib/rbenchmarker/prepend_modules.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Rbenchmarker
+  module PrependModules
+    def self.register_rbenchmarker_methods_to_module(object_with_has_modules, module_with_has_methods_lists, except_modules)
+      object_with_has_modules.each do |obj, granted_modules|
+        if granted_modules[:prepend].is_a?(Array)
+          methods_setup(granted_modules, :prepend, obj, except_modules, module_with_has_methods_lists)
+        end
+
+        if granted_modules[:include].is_a?(Array)
+          methods_setup(granted_modules, :include, obj, except_modules, module_with_has_methods_lists)
+        end
+
+        if granted_modules[:extend].is_a?(Array)
+          methods_setup(granted_modules, :extend, obj, except_modules, module_with_has_methods_lists)
+        end
+      end
+    end
+
+    # private
+
+    def self.methods_setup(granted_modules, include_type, obj, except_modules, module_with_has_methods_lists)
+      granted_modules[include_type].each do |benchmark_module|
+        next if except_modules.include?(benchmark_module)
+        next unless module_with_has_methods_lists[benchmark_module.to_s.to_sym]
+
+        case include_type
+        when :prepend
+          obj.prepend module_with_has_methods_lists[benchmark_module.to_s.to_sym]
+        when :include
+          obj.include module_with_has_methods_lists[benchmark_module.to_s.to_sym]
+        when :extend
+          obj.extend module_with_has_methods_lists[benchmark_module.to_s.to_sym]
+        end
+      end
+    end
+
+    private_class_method :methods_setup
+  end
+end

data/lib/rbenchmarker/rbenchmarker_log.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Rbenchmarker
+  module RbenchmarkerLog
+    def self.init_log
+      @logger = Logger.new(Rbenchmarker.output_log_file_path)
+      @logger.info("== Start recording Rbenchmarker == \n")
+    end
+
+    def self.puts_log(label, report, number_of_digits: 8)
+      return unless defined? @logger
+
+      log_text = "\n"
+      log_text += "#{label}: current time\n"
+      log_text += "user: #{format("%.#{number_of_digits}f", report[:utime][-1])}, "
+      log_text += "system: #{format("%.#{number_of_digits}f", report[:stime][-1])}, "
+      log_text += "total: #{format("%.#{number_of_digits}f", report[:total][-1])}, "
+      log_text += "real: #{format("%.#{number_of_digits}f", report[:real][-1])}\n"
+
+      log_text += "#{label}: total time for #{report[:number_of_executions]} times called\n"
+      log_text += "user: #{format("%.#{number_of_digits}f", report[:utime].sum)}, "
+      log_text += "system: #{format("%.#{number_of_digits}f", report[:stime].sum)}, "
+      log_text += "total: #{format("%.#{number_of_digits}f", report[:total].sum)}, "
+      log_text += "real: #{format("%.#{number_of_digits}f", report[:real].sum)}\n"
+
+      log_text += "#{label}: avarage time\n"
+      log_text += "user: #{format("%.#{number_of_digits}f", (report[:utime].sum / report[:number_of_executions]))}, "
+      log_text += "system: #{format("%.#{number_of_digits}f", (report[:stime].sum / report[:number_of_executions]))}, "
+      log_text += "total: #{format("%.#{number_of_digits}f", (report[:total].sum / report[:number_of_executions]))}, "
+      log_text += "real: #{format("%.#{number_of_digits}f", (report[:real].sum / report[:number_of_executions]))}\n"
+
+      @logger.info(log_text)
+    end
+  end
+end

data/lib/rbenchmarker/register_rbenchmarker_methods.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+
+module Rbenchmarker
+  module RegisterRbenchmarkerMethods
+    DEFAULT_REPORT_LENGTH = 30
+    TIMES_THE_METHOD_WAS_CALLED = 1
+
+    # "rbenchmarker" needs to start processing after all the methods of the target class(file) have been read,
+    # Rbenchmarker uses the benchmark library (https://docs.ruby-lang.org/ja/latest/class/Benchmark.html) internally.
+    #
+    # "all" option performs static analysis to identify the target method, so put "__FILE__" in the argument. normally, set this option.
+    #
+    # method specified in "only" will not be benchmarked.
+    # method specified in "except" will not be benchmarked.
+    # method specified by "added" is added to the benchmark after the "only" and "except" method filtering is done.
+    #
+    # "label_width" specifies the width of the benchmark label.
+    #
+    # benchmark is measured by repeatedly executing the benchmarked method for the number of times specified by "times".
+    # Keep in mind that code such as SQL queries will also be executed repeatedly.
+    #
+    # "require_hidden_method" option is set to true, methods created dynamically by metaprogramming will also be targeted.
+    #
+    # in the "include" option, specify the module that you are including. Arrange the option array in the loading order of the modules to be included.
+    # in the "extend" option, specify the module that you are extending. Arrange the option array in the loading order of the modules to be extended.
+    # in the "prepend" option, specify the module that you are prepending. Arrange the option array in the loading order of the modules to be prepended.
+    def self.register_rbenchmarker_methods(
+      all: nil,
+      only: [],
+      except: [],
+      added: [],
+      label_width: 0,
+      times: 0,
+      require_hidden_method: false,
+      object_type: nil,
+      target_obj: nil
+    )
+      # Collect the method names to be benchmarked.
+      target_instance_method_names, target_class_method_names = collect_target_methods(
+        target_obj, all, require_hidden_method, only, except, added
+      )
+
+      # Add benchmark function to the method to be benchmarked.
+      instance_method_codes_with_benchmark_function = generate_benchmarking_codes(
+        target_instance_method_names, label_width, times, (object_type == 'Module' ? 'module' : 'instance')
+      )
+      class_method_codes_with_benchmark_function = generate_benchmarking_codes(
+        target_class_method_names, label_width, times, (object_type == 'Module' ? 'module' : 'class')
+      )
+
+      # Override the original method with the benchmark functionality.
+      prepended_instance_methods = prepend_benchmarking_methods(instance_method_codes_with_benchmark_function)
+      prepended_class_methods = prepend_benchmarking_methods(class_method_codes_with_benchmark_function)
+
+      case object_type
+      when 'Module'
+        Rbenchmarker.add_module_with_has_methods_list(target_obj.to_s.to_sym, prepended_instance_methods)
+      when 'Class'
+        target_obj.prepend prepended_instance_methods
+      end
+
+      target_obj.singleton_class.prepend prepended_class_methods
+    end
+
+    # private
+
+    def self.collect_target_methods(target_obj, target_file, require_hidden_method, only, except, added)
+      if require_hidden_method
+        instance_method_name_candidates = target_obj.instance_methods(false) + target_obj.private_instance_methods(false)
+        class_method_name_candidates = target_obj.singleton_methods(false)
+      elsif target_file
+        instance_method_name_candidates, class_method_name_candidates =
+          statically_analyze_and_extract_target_method_names(target_obj, target_file)
+      else
+        instance_method_name_candidates = []
+        class_method_name_candidates = []
+      end
+
+      filtered_instance_method_names =
+        filter_by_only_except_and_added(instance_method_name_candidates, only, except, added, target_obj, 'instance_method')
+      filtered_class_method_names =
+        filter_by_only_except_and_added(class_method_name_candidates, only, except, added, target_obj, 'class_method')
+
+      [filtered_instance_method_names, filtered_class_method_names]
+    end
+
+    def self.statically_analyze_and_extract_target_method_names(target_obj, target_file)
+      instance_method_name_candidates = []
+      class_method_name_candidates = []
+      words = []
+
+      all_class_methods = target_obj.singleton_methods(false)
+      all_instance_methods = target_obj.instance_methods(false) + target_obj.private_instance_methods(false)
+      File.foreach(target_file) { |line| words << line[/def\ (.*?)[ ;|\(\n]/, 1] }
+      user_described_all_method_names = words.compact.map { |word| word.match(/^self\./) ? word.gsub(/^self\./, '') : word }
+
+      user_described_all_method_names.each do |def_name|
+        class_method_name_candidates << def_name.to_sym if all_class_methods.include?(def_name.to_sym)
+        instance_method_name_candidates << def_name.to_sym if all_instance_methods.include?(def_name.to_sym)
+      end
+
+      [instance_method_name_candidates.uniq, class_method_name_candidates.uniq]
+    end
+
+    def self.filter_by_only_except_and_added(method_names, only, except, added, target_obj, method_type)
+      has_methods = case method_type
+                    when 'instance_method'
+                      target_obj.instance_methods(false) + target_obj.private_instance_methods(false)
+                    when 'class_method'
+                      target_obj.singleton_methods(false)
+                    end
+
+      added = added.select { |method_name| has_methods.include?(method_name) }
+
+      if !only.empty?
+        ((method_names & only) + added).uniq
+      elsif !except.empty?
+        (method_names - except + added).uniq
+      else
+        (method_names + added).uniq
+      end
+    end
+
+    def self.generate_benchmarking_codes(method_names, width, times, class_type)
+      method_names.map { |method_name| define_benchmarking_code(method_name, width, times, class_type) }
+    end
+
+    def self.define_benchmarking_code(method_name, width, times, class_type)
+      times_to_i = times.to_i.nonzero?
+      generate_report_function_code = generate_report_method_text('bm_result')
+
+      <<-RUBY_EVAL
+        def #{method_name}(*)
+          origin_return_value = nil
+          bm_result = # 'bm_result' is Arguments of 'generate_report_method_text'
+            Benchmark.bm #{width.to_i.nonzero? || method_name.length + DEFAULT_REPORT_LENGTH} do |r|
+              r.report "report def #{method_name}#{"(#{times_to_i}" if times_to_i}#{' loops)' if times_to_i} #{class_type} method" do
+                #{times_to_i ? "#{times_to_i}.times{ origin_return_value = super }" : 'origin_return_value = super'}
+              end
+            end
+          #{generate_report_function_code}
+          origin_return_value
+        end
+      RUBY_EVAL
+    end
+
+    def self.generate_report_method_text(bm_report_name)
+      <<-RUBY_EVAL
+        new_report = #{bm_report_name}.first
+        bm_reports = Rbenchmarker.tracking_reports
+        if bm_reports[new_report.label.to_sym]
+          previous_report = bm_reports[new_report.label.to_sym]
+          key = new_report.label.to_sym
+          value = {
+            utime: previous_report[:utime] << new_report.utime,
+            stime: previous_report[:stime] << new_report.stime,
+            total: previous_report[:total] << new_report.total,
+            real: previous_report[:real] << new_report.real,
+            number_of_executions: previous_report[:number_of_executions] + 1
+          }
+          Rbenchmarker.add_report(key, value)
+        else
+          key = new_report.label.to_sym
+          value = {
+            utime: [new_report.utime],
+            stime: [new_report.stime],
+            total: [new_report.total],
+            real: [new_report.real],
+            number_of_executions: TIMES_THE_METHOD_WAS_CALLED
+          }
+          Rbenchmarker.add_report(key, value)
+        end
+      RUBY_EVAL
+    end
+
+    def self.prepend_benchmarking_methods(benchmarking_codes)
+      Module.new do
+        benchmarking_codes.each { |code| class_eval code, __FILE__, __LINE__ + 1 }
+      end
+    end
+
+    private_class_method :collect_target_methods
+    private_class_method :statically_analyze_and_extract_target_method_names
+    private_class_method :filter_by_only_except_and_added
+    private_class_method :generate_benchmarking_codes
+    private_class_method :define_benchmarking_code
+    private_class_method :generate_report_method_text
+    private_class_method :prepend_benchmarking_methods
+  end
+end

data/lib/rbenchmarker/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Rbenchmarker
+  VERSION = '0.1.1'
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: rbenchmarker
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- daiki shibata
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-02-05 00:00:00.000000000 Z
+dependencies: []
+description: |
+  Rbenchmarker is a gem that allows you to automatically benchmark the execution time of a method defined in a Ruby class and module. Benchmark module (https://docs.ruby-lang.org/ja/latest/class/Benchmark.html) is used inside Rbenchmarker, and bm method is automatically applied to all target methods.
+  However, ｍethod itself to which Rbenchmarker is applied remains unchanged, takes the same arguments as before, and returns the same return value as before.
+  So you don't have to change the methods yourself, and you don't have to benchmark the methods one by one. Just launch the application as before and will automatically benchmark all targeted methods!
+email:
+- shibatadaiki92@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- MIT-LICENSE
+- README.md
+- lib/rbenchmarker.rb
+- lib/rbenchmarker/class_methods.rb
+- lib/rbenchmarker/exceptions.rb
+- lib/rbenchmarker/prepend_modules.rb
+- lib/rbenchmarker/rbenchmarker_log.rb
+- lib/rbenchmarker/register_rbenchmarker_methods.rb
+- lib/rbenchmarker/version.rb
+homepage: https://github.com/shibatadaiki/Rbenchmarker
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/shibatadaiki/Rbenchmarker
+  source_code_uri: https://github.com/shibatadaiki/Rbenchmarker/
+  changelog_uri: https://github.com/shibatadaiki/Rbenchmarker/blob/master/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.3
+signing_key:
+specification_version: 4
+summary: Automatically log benchmarks for all methods
+test_files: []