method_call_tracer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c0a180a16f9d4798139f03dc6cc487632ec0cfbf
+  data.tar.gz: d7294c63a4bc0e293fa9e883338248aee417c050
+SHA512:
+  metadata.gz: 9f03140a84d526cc297d97c650ae3a55df9e28dbfe2b5d8be5ed832aee97689a73b4eb2402faaca16d5ad1a9b2a2c434fe9f1d4032041b45cabc2e2135e818d8
+  data.tar.gz: 2e36e0b7bcbb327ffa925f3667f23532238d47956ca70ce6a46e852732aca43b700288473bd45fe82eefcb0854ccab39310fe69849ea68b49448d9fd23601f1b

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/Gemfile.lock
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Metrics/LineLength:
+  Max: 100

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in method_tracer.gemspec
+gemspec

data/README.md

@@ -0,0 +1,58 @@
+# MethodTracer
+
+MethodTracer is a tool for detecting lines in an application that call certain methods, somewhat akin to the syscall monitoring functionality of strace(1). The methods to be traced are specified by file pattern, which makes it simple to trace an entire gem<sup>1</sup>. The most common use case is helping developers and testers focus their efforts when upgrading or changing gems in large applications.
+
+<sup>1</sup> Designating traced methods by file lets you trace methods defined in the "namespace" of a different gem. For example, if a hypothetical gem `activerecord-extension` defines some methods on the class `ActiveRecord`, we still have the ability to trace only the methods from `activerecord-extension` without capturing the methods from `activerecord`.
+
+## Usage
+
+To attach tracers to methods, instantiate `MethodTracer::Tracer` objects. For Rails applications, these can be placed in the provided initializer.
+
+```ruby
+# Trace all methods defined by the system installation of gibbon:
+MethodTracer::Tracer.new('/var/lib/gems/2.3.0/gems/gibbon-2.2.4/')
+
+# Trace all methods defined by rbenv's 2.3.3 installation of activerecord:
+MethodTracer::Tracer.new('/home/eddie/.rbenv/versions/2.3.3/lib/ruby/gems/2.3.0/gems/activerecord-5.0.7/')
+```
+
+With tracers attached, exercise as much of the application as possible. Perhaps run the comprehensive test suite that you of course have.
+
+## Configuration
+
+MethodTracer supports the following configuration options:
+
+`MethodTracer::Config.app_path`: The path of the application to trace calls from. MethodTracer will only report portions of call chains that are inside this path. Set it to `Rails.application.paths.path.to_s` for Rails applications. Set it to `'/'` or `''` to report all calls.
+
+`MethodTracer::Config.output_file`: A filename or `IO` or `StringIO` object where the report output should be sent. Defaults to `$stdout`.
+
+## Limitations
+
+MethodTracer theoretically does not interfere with the original behavior of methods being traced. However, certain gems are known to misbehave when the tracing logic is monkeypatched in, and MethodTracer will refuse to trace those gems. Furthermore, any methods defined after the `MethodTracer::Tracer` is instantiated will remain untraced.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'method_tracer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install method_tracer
+
+If you are using it with Rails, run the installation generator to install an example config initializer:
+
+    $ rails generate method_tracer:install
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/elebow/method_tracer.
+
+## License
+This gem is dedicated to the public domain. In jurisdictions where this is not possible, this gem is licensed to all under the least restrictive terms possible, and the author waives all waivable copyright rights.

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 'method_tracer'
+
+# 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(__FILE__)

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/generators/method_tracer/install_generator.rb

@@ -0,0 +1,12 @@
+module MethodTracer
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.dirname(__FILE__) + '/templates'
+      desc 'Installs initializer'
+
+      def install
+        template 'initializer.rb', 'config/initializers/method_tracer.rb'
+      end
+    end
+  end
+end

data/lib/generators/method_tracer/templates/initializer.rb

@@ -0,0 +1,11 @@
+# Define the prefix for the application code. Only calls matching this pattern
+# will be recorded.
+MethodTracer::Config.app_path = Rails.application.paths.path.to_s
+
+# Override the default output file. Specify a filename string or an IO or StringIO object
+# like `$stdout`.
+# MethodTracer::Config.output_file = 'output_file_2.log'
+
+# Create a MethodTracer::Spy object for every gem to be spied on
+# MethodTracer::Tracer.new('/var/lib/gems/2.3.0/gems/gibbon-2.2.4/lib/gibbon/')
+# MethodTracer::Tracer.new('/var/lib/gems/2.3.0/gems/other_gem-1.0.0/lib/other_gem-1.0.0/')

data/lib/method_tracer/tracer.rb

@@ -0,0 +1,101 @@
+module MethodTracer
+  class Tracer
+    UNCOOPERATIVE_NAMES = [
+      # Some classes don't behave well when we try to hook them, at least with
+      # the methods currently used.
+      'CGI',    # Waits for input from stdin when opening rails console
+      'RSpec'   # RSpec doesn't run
+    ].freeze
+
+    def initialize(target)
+      @target_path = target
+
+      find_methods!
+
+      add_hooks_to_class_methods
+      add_hooks_to_instance_methods
+    end
+
+    def self.uncooperative_class?(class_name)
+      !class_name.nil? &&
+        UNCOOPERATIVE_NAMES.any? { |bad_name| class_name.include?(bad_name) }
+    end
+
+    def self.record_and_call_original(unbound_m, receiver, *args, &block)
+      outfile.write "#{receiver}.#{unbound_m.name} called from:\n"
+      caller_locations.select { |loc| loc.path.start_with?(Config.app_path) }
+                      .each do |loc|
+                        outfile.write "#{loc.path}:#{loc.lineno}\n"
+                      end
+
+      unbound_m.bind(receiver).call(*args, &block)
+    end
+
+    def self.outfile
+      @outfile ||= begin
+                     output_file = Config.output_file
+                     if output_file.instance_of?(IO) || output_file.instance_of?(StringIO)
+                       output_file
+                     elsif output_file.instance_of?(String)
+                       File.open(output_file, 'a')
+                     else
+                       raise "Unhandled output_file type: #{output_file}"
+                     end
+                   end
+    end
+
+    private
+
+    def add_hooks_to_class_methods
+      methods_of_interest(@all_class_methods).each do |m|
+        unbound_m = m.unbind
+        receiver = m.receiver
+
+        receiver.send(:define_singleton_method, unbound_m.name) do |*args, &block|
+          Tracer.record_and_call_original(unbound_m, receiver, *args, &block)
+        end
+      end
+    end
+
+    def add_hooks_to_instance_methods
+      methods_of_interest(@all_instance_methods).each do |m|
+        unbound_m = m.unbind
+        receiver = m.receiver
+
+        receiver.class.send(:define_method, m.name) do |*args, &block|
+          Tracer.record_and_call_original(unbound_m, receiver, *args, &block)
+        end
+      end
+    end
+
+    def find_methods!
+      @all_class_methods = []
+      @all_instance_methods = []
+      ObjectSpace.each_object(Class) do |defined_class|
+        next if Tracer.uncooperative_class?(defined_class.name)
+
+        defined_class.methods(false).each do |method_sym|
+          @all_class_methods << defined_class.method(method_sym)
+        end
+
+        begin
+          instance = defined_class.new
+          defined_class.instance_methods(false).each do |method_sym|
+            @all_instance_methods << instance.method(method_sym)
+          end
+        rescue StandardError, NotImplementedError, LoadError
+          # If the class isn't instantiable, skip it
+          next
+        end
+      end
+    end
+
+    def methods_of_interest(methods)
+      methods.select do |m|
+        m.instance_of?(Method) &&
+          !m.source_location.nil? &&
+          m.source_location[0].start_with?(@target_path)
+      end
+    end
+  end
+end

data/lib/method_tracer/version.rb

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

data/lib/method_tracer.rb

@@ -0,0 +1,13 @@
+require 'method_tracer/tracer'
+
+require 'method_tracer/version'
+
+module MethodTracer
+  class Config
+    class << self
+      attr_accessor :app_path, :output_file
+    end
+
+    @output_file = $stdout
+  end
+end

data/method_tracer.gemspec

@@ -0,0 +1,25 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'method_tracer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'method_call_tracer'
+  spec.version       = MethodTracer::VERSION
+  spec.authors       = ['Eddie Lebow']
+  spec.email         = ['elebow@users.noreply.github.com']
+
+  spec.summary       = 'A tool that finds lines in your application that call a specified method'
+  spec.description   = 'This tool wraps every specified method with some logging statements ' \
+                       'that record the call stack, allowing you to see exactly which lines in ' \
+                       'your application make calls to methods in question. The specified ' \
+                       'methods can constitute all methods defined in a certain gem.'
+  spec.homepage      = 'https://github.com/elebow/method_tracer'
+  spec.license       = 'public domain'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'minitest', '~> 0'
+end

data/run_tests.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+if [ "$#" -ge 1 ]; then
+	name_arg=--name "$*"
+else
+	name_arg=""
+fi
+
+bundle e ruby -Ilib:test "$(find test -name "*_test.rb")" $name_arg

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: method_call_tracer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Eddie Lebow
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-09-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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'
+description: This tool wraps every specified method with some logging statements that
+  record the call stack, allowing you to see exactly which lines in your application
+  make calls to methods in question. The specified methods can constitute all methods
+  defined in a certain gem.
+email:
+- elebow@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/generators/method_tracer/install_generator.rb
+- lib/generators/method_tracer/templates/initializer.rb
+- lib/method_tracer.rb
+- lib/method_tracer/tracer.rb
+- lib/method_tracer/version.rb
+- method_tracer.gemspec
+- run_tests.sh
+homepage: https://github.com/elebow/method_tracer
+licenses:
+- public domain
+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.5.2.1
+signing_key: 
+specification_version: 4
+summary: A tool that finds lines in your application that call a specified method
+test_files: []