pilfer 0.0.1.pre3 → 0.0.1.pre4

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NzkwNzViNDg0NTFlMDIyNmU5YWMwYTYxNmY3NmE1YjJlYjgyY2IxOQ==
+    NzFkODBmMDU3MzMxMmQ2MGRiYjZhMmI2Y2I2OWQ4NmE0YzVlMmJiOQ==
   data.tar.gz: !binary |-
-    ZjcwZjRkNzZiNzI0MjllYTE0NzUzYWQyNWZlOTM2MzQ4MzA3MGNkNA==
+    ZjVlOGMyYWFiNjM5ZWIyODI5NGU5MDI3YWYxZmJmNGM3YzFlNWQ4Nw==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    YTlhYzBiMGRjYTY5OTdiYzM4MTlmODdkZWI5MTBhZmRiN2Q1ZGYxOGNmZjVl
-    Yjk5ZDVhMGFmOWEyYTUwNTFmM2MzZTYwZDZhMzQ0MzExNDVhNTE0ODZlNGYy
-    OWM3NTY3N2NmZWQ2ZTUzM2Q3YmU2MzhjOTA1NzIxMmM3Y2U1OWY=
+    NTI5NjVlNGNlNGU0NzlkNzgwYWI0YTYyMjhmNmMzYWQyOWQwOWFkYmJiN2Ey
+    NTY4NWUxOTRkOTRjNjlhZjA3ZmEwNWFmOWQ2YmRlYjhmNjEyNjJiMDg2OWY2
+    NTA0MTZhYWI3YzYzOWE5OWZkODRmMWI4MGI3MjhkYjEwYzk0NGU=
   data.tar.gz: !binary |-
-    NTE4OTU1OGQwYWExYjI0ZjE4YTFjN2RmNDExZGUxZTA5ZDUzYjZjYjE1MGNh
-    MWY3NjkxYjY2N2Q3YjYyNzJlODFlZjQ2NjVmODU5ZThkMWE1OWRjNDkzNDNj
-    MmUxYjAxMzZlNTcxMmRmYzZiZWIzNWU0Zjk0ZWVkMGI3ZTA2Njg=
+    YzY3Mzk5N2VlNzBiNzdmMWU2ZDBhNDMxMGEwNDVhODQwMTI1MTRhMWQxODJk
+    OGM1MDIzYjVlYTVkYTFkYTU5MjMwNzE2ZDA5YjkxNzEzZWU5OWYwYzc5OTU3
+    OWVhZmQ0YTc5NGNmNTY3MWU0Zjk0ZDc1NDA5ZmVmODg0ZmE4YTU=

data/Gemfile

@@ -1,4 +1,7 @@
 source 'https://rubygems.org'
 
-gem 'rblineprof', github: 'tmm1/rblineprof'
+gem 'json', :platforms => [:ruby_18]
+gem 'rspec', '~> 2.13'
+gem 'rack',  '~> 1.5.2'
+
 gemspec

data/README.md

@@ -77,9 +77,9 @@ reporter = Pilfer::Server.new('https://pilfer.com', 'abc123')
 Profile your Rack or Rails app using `Pilfer::Middleware`.
 
 ```ruby
-reporter = Pilfer::Server.new('https://pilfer.com', 'abc123'
-                              :app_root => Rails.root)
-use Pilfer::Middleware, reporter
+reporter = Pilfer::Logger.new($stdout, :app_root => Rails.root)
+profiler = Pilfer::Profiler.new(reporter)
+use Pilfer::Middleware :profiler => profiler
 ```
 
 Restrict the files profiled by passing a regular expression with
@@ -87,14 +87,15 @@ Restrict the files profiled by passing a regular expression with
 
 ```ruby
 matcher = %r{^#{Regexp.escape(Rails.root.to_s)}/(app|config|lib|vendor/plugin)}
-use Pilfer::Middleware, reporter, :files_matching => matcher
+use Pilfer::Middleware, :files_matching => matcher,
+                        :profiler       => profiler
 ```
 
 You probably don't want to profile _every_ request. The given block will be
 evaluated on each request to determine if a profile should be run.
 
 ```ruby
-use Pilfer::Middleware, reporter do
+use Pilfer::Middleware, :profiler => profiler do
   # Profile 1% of requests.
   rand(100) == 1
 end
@@ -103,7 +104,7 @@ end
 The Rack environment is available to allow profiling on demand.
 
 ```ruby
-use Pilfer::Middleware, reporter do |env|
+use Pilfer::Middleware, :profiler => profiler do |env|
   env.query_string.include? 'profile=true'
 end
 ```

data/lib/pilfer/logger.rb

@@ -8,7 +8,7 @@ module Pilfer
     def initialize(path_or_io, options = {})
       @logger = ::Logger.new(path_or_io)
       if (app_root = options[:app_root])
-        app_root += '/' unless app_root[-1] == '/'
+        app_root += '/' unless app_root[-1, 1] == '/'
         @app_root = %r{^#{Regexp.escape(app_root)}}
       end
     end
@@ -25,7 +25,8 @@ module Pilfer
     private
 
     def print_report_banner(profile_start)
-      logger.info "Profile start=#{profile_start.utc.to_s}"
+      formatted_start = profile_start.utc.strftime('%Y-%m-%d %H:%M:%S UTC')
+      logger.info "Profile start=#{formatted_start}"
     end
 
     def print_file_banner(path, data)

data/lib/pilfer/middleware.rb

@@ -0,0 +1,36 @@
+require 'pilfer/logger'
+require 'pilfer/profiler'
+
+module Pilfer
+  class Middleware
+    attr_accessor :app, :profiler, :file_matcher, :profile_guard
+
+    def initialize(app, options = {}, &profile_guard)
+      @app           = app
+      @profiler      = options[:profiler] || default_profiler
+      @file_matcher  = options[:file_matcher]
+      @profile_guard = profile_guard
+    end
+
+    def call(env)
+      if profile_guard.call(env)
+        run_profiler { app.call(env) }
+      else
+        app.call(env)
+      end
+    end
+
+    def run_profiler(&downstream)
+      if file_matcher
+        profiler.profile_files_matching(file_matcher, &downstream)
+      else
+        profiler.profile(&downstream)
+      end
+    end
+
+    def default_profiler
+      reporter = Pilfer::Logger.new($stdout, :app_root => ENV['PWD'])
+      Pilfer::Profiler.new(reporter)
+    end
+  end
+end

data/lib/pilfer/profile.rb

@@ -9,19 +9,18 @@ module Pilfer
     end
 
     def each(&block)
-      files.each(&block)
+      files.to_a.sort_by(&:first).each(&block)
     end
 
     def files
-      data.each_with_object({}) do |(file, lines), files|
-        profile_lines = lines[1..-1].
-                          each_with_index.
-                          each_with_object({}) do |(data, number), lines|
+      data.inject({}) do |files, (file, lines)|
+        profile_lines = {}
+        lines[1..-1].each_with_index do |data, number|
           next unless data.any? {|datum| datum > 0 }
           wall_time, cpu_time, calls = data
-          lines[number] = { 'wall_time' => wall_time,
-                            'cpu_time'  => cpu_time,
-                            'calls'     => calls }
+          profile_lines[number] = { 'wall_time' => wall_time,
+                                    'cpu_time'  => cpu_time,
+                                    'calls'     => calls }
         end
 
         total_wall, child_wall, exclusive_wall,
@@ -33,6 +32,7 @@ module Pilfer
         files[file] = { 'wall_time' => wall,
                         'cpu_time'  => cpu,
                         'lines'     => profile_lines }
+        files
       end
     end
   end

data/lib/pilfer/version.rb

@@ -1,3 +1,3 @@
 module Pilfer
-  VERSION = '0.0.1.pre3'
+  VERSION = '0.0.1.pre4'
 end

data/pilfer.gemspec

@@ -14,19 +14,12 @@ Gem::Specification.new do |spec|
   spec.files = %w(Gemfile LICENSE README.md)
   spec.files << 'pilfer.gemspec'
   spec.files += Dir.glob('lib/**/*.rb')
-  spec.files += Dir.glob('test/**/*.rb')
+  spec.files += Dir.glob('spec/**/*.rb')
   spec.files += Dir.glob('script/*')
-  spec.test_files = Dir.glob('test/**/*.rb')
+  spec.test_files = Dir.glob('spec/**/*.rb')
 
+  spec.add_dependency 'rblineprof', '~> 0.3.2'
   spec.add_development_dependency 'bundler', '~> 1.0'
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'rack', '~> 1.5.2'
 
   spec.required_rubygems_version = '>= 1.3.6'
-
-  # Bundled latest rblineprof
-  spec.extensions = 'ext/extconf.rb'
-  spec.files += Dir.glob('ext/*')
-  spec.add_dependency 'debugger-ruby_core_source', '~> 1.2'
 end

data/spec/files/hello.rb

@@ -0,0 +1 @@
+print 'Hello '

data/spec/files/test.rb

@@ -0,0 +1,17 @@
+require 'bundler/setup'
+require 'pilfer/logger'
+require 'pilfer/profiler'
+require 'stringio'
+
+output   = StringIO.new
+reporter = Pilfer::Logger.new(output)
+profiler = Pilfer::Profiler.new(reporter)
+path     = File.expand_path(File.dirname(__FILE__))
+
+profiler.profile_files_matching(%r{^#{Regexp.escape(path)}}) do
+  require 'hello'
+  puts 'world!'
+  10.times do
+    sleep 0.01
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,7 @@
+require 'bundler/setup'
+
+RSpec.configure do |config|
+  config.filter_run :focused => true
+  config.run_all_when_everything_filtered = true
+  config.alias_example_to :fit, :focused => true
+end

data/spec/pilfer/logger_spec.rb

@@ -0,0 +1,88 @@
+require 'helper'
+require 'json'
+require 'tempfile'
+require 'pilfer/logger'
+
+describe Pilfer::Logger do
+  let(:spec_root) { File.expand_path('..', File.dirname(__FILE__)) }
+  let(:profile)   {
+    profile_file    = File.join(spec_root, 'files', 'profile.json')
+    profile_content = File.read(profile_file).gsub('SPEC_ROOT', spec_root)
+    JSON.parse(profile_content)
+  }
+  let(:reporter) { StringIO.new }
+  let(:start)    { Time.at(42) }
+  let(:output) {
+    reporter.string.each_line.map {|line|
+      line.sub(/I, \[[^\]]+\]  INFO -- : /, '')
+    }.join
+  }
+  let(:first_file) {
+    output.
+      split("\n")[1].
+      split(' ').
+      first
+  }
+
+  describe '#write' do
+    it 'writes profile to reporter' do
+      expected = <<-EOS
+Profile start=1970-01-01 00:00:42 UTC
+#{spec_root}/files/hello.rb wall_time=0.0ms cpu_time=0.0ms
+     0.0ms (    2) | print 'Hello '
+#{spec_root}/files/test.rb wall_time=113.7ms cpu_time=5.3ms
+                   | require 'bundler/setup'
+                   | require 'pilfer/logger'
+                   | require 'pilfer/profiler'
+                   | require 'stringio'
+                   | 
+                   | output   = StringIO.new
+                   | reporter = Pilfer::Logger.new(output)
+                   | profiler = Pilfer::Profiler.new(reporter)
+                   | path     = File.expand_path(File.dirname(__FILE__))
+                   | 
+                   | profiler.profile_files_matching(%r{^\#{Regexp.escape(path)}}) do
+     5.1ms (    3) |   require 'hello'
+     0.0ms (    4) |   puts 'world!'
+   108.6ms (    1) |   10.times do
+   108.4ms (   10) |     sleep 0.01
+                   |   end
+                   | end
+EOS
+      Pilfer::Logger.new(reporter).write(profile, start)
+      output.should eq(expected)
+    end
+
+    it 'omits app root' do
+      Pilfer::Logger.new(reporter, :app_root => spec_root).
+        write(profile, start)
+      first_file.should eq('files/hello.rb')
+    end
+
+    it 'omits app root with trailing separator' do
+      Pilfer::Logger.new(reporter, :app_root => spec_root + '/').
+        write(profile, start)
+      first_file.should eq('files/hello.rb')
+    end
+
+    context 'with a nonexistent file' do
+      let(:profile) {{
+        "(eval)" => [[113692, 31, 5026, 5313, 18, 4868], [0, 0, 0]]
+      }}
+
+      it 'omits the source of the nonexistent file' do
+        expected = <<-EOS
+Profile start=1970-01-01 00:00:42 UTC
+(eval) wall_time=113.7ms cpu_time=5.3ms
+EOS
+        Pilfer::Logger.new(reporter).write(profile, start)
+        output.should eq(expected)
+      end
+    end
+
+    it 'appends to the log file' do
+      3.times { Pilfer::Logger.new(reporter).write(profile, start) }
+      output.scan('Profile start=').size.should eq(3)
+    end
+  end
+end

data/spec/pilfer/middleware_spec.rb

@@ -0,0 +1,55 @@
+require 'helper'
+require 'rack/mock'
+require 'pilfer/middleware'
+
+describe Pilfer::Middleware do
+  let(:env)      { Rack::MockRequest.env_for }
+  let(:app)      { stub(:app, :call => nil) }
+  let(:profiler) { stub(:profiler, :profile => nil) }
+  let(:options)  {{ :profiler => profiler }}
+  let(:guard)    { Proc.new do true end }
+  subject { Pilfer::Middleware.new(app, options, &guard) }
+
+  it 'profiles and calls the downstream app' do
+    app.should_receive(:call).with(env).once
+    profiler.should_receive(:profile).with(no_args).and_yield
+    subject.call(env)
+  end
+
+  it 'passes rack env to guard' do
+    guard_args = nil
+    guard = lambda do |*args| guard_args = args end
+
+    Pilfer::Middleware.new(app, options, &guard).call(env)
+    guard_args.should_not be_nil
+    guard_args.size.should eq(1)
+    guard_args.first.should eq(env)
+  end
+
+  context 'with file matcher' do
+    let(:file_matcher) { stub(:file_matcher) }
+    let(:options)      {{ :file_matcher => file_matcher,
+                          :profiler     => profiler }}
+
+    it 'passes file matcher to profiler and calls the downstream app' do
+      app.should_receive(:call).with(env).once
+      profiler.should_receive(:profile_files_matching).with(file_matcher).
+        and_yield
+      subject.call(env)
+    end
+  end
+
+  context 'when guard returns false' do
+    let(:guard) { Proc.new do false end }
+
+    it 'calls the downstream app' do
+      app.should_receive(:call).with(env).once
+      subject.call(env)
+    end
+
+    it 'skips profiling' do
+      profiler.should_not_receive(:profile)
+      subject.call(env)
+    end
+  end
+end

data/spec/pilfer/profile_spec.rb

@@ -0,0 +1,61 @@
+require 'helper'
+require 'json'
+require 'pilfer/profile'
+
+describe Pilfer::Profile do
+  let(:spec_root) { File.expand_path('..', File.dirname(__FILE__)) }
+  let(:data)      {
+    profile_file    = File.join(spec_root, 'files', 'profile.json')
+    profile_content = File.read(profile_file).gsub('SPEC_ROOT', spec_root)
+    JSON.parse(profile_content)
+  }
+  let(:start) { Time.at(42) }
+  subject { Pilfer::Profile.new(data, start) }
+
+  it 'should be an Enumerable' do
+    subject.should be_kind_of(Enumerable)
+  end
+
+  describe '#start' do
+    it 'returns the given start time' do
+      subject.start.should eq(start)
+    end
+  end
+
+  describe '#each' do
+    it 'yields each file and data' do
+      actual  = {}
+      subject.each do |file, data|
+        actual[file] = data
+      end
+      expected = {
+        "#{spec_root}/files/hello.rb" => {
+          "wall_time" => 31,
+          "cpu_time"  => 18,
+          "lines"     => {
+            0 => { "wall_time" => 31, "cpu_time" => 18, "calls" => 2} }
+        },
+        "#{spec_root}/files/test.rb" => {
+          "wall_time" => 113692,
+          "cpu_time"  => 5313,
+          "lines"     => {
+            11 => { "wall_time" => 5062,   "cpu_time" => 4890, "calls" => 3 },
+            12 => { "wall_time" => 23,     "cpu_time" => 14,   "calls" => 4 },
+            13 => { "wall_time" => 108607, "cpu_time" => 409,  "calls" => 1 },
+            14 => { "wall_time" => 108404, "cpu_time" => 310,  "calls" => 10 }
+          }
+        }
+      }
+      actual.should eq(expected)
+    end
+
+    it 'yields each file alphabetically' do
+      actual = []
+      subject.each do |file, data|
+        actual << file
+      end
+      expected = %W(#{spec_root}/files/hello.rb #{spec_root}/files/test.rb)
+      actual.should eq(expected)
+    end
+  end
+end

data/spec/pilfer/profiler_spec.rb

@@ -0,0 +1,52 @@
+require 'helper'
+require 'pilfer/profiler'
+
+describe Pilfer::Profiler do
+  let(:reporter) { stub(:reporter, :write => nil) }
+  let(:start)    { stub(:start) }
+
+  describe '#profile' do
+    it 'profiles all files by default' do
+      profiler = stub(:profiler)
+      profiler.should_receive(:call).with(/./)
+      Pilfer::Profiler.new(reporter).profile(profiler) { }
+    end
+
+    it 'returns value of app' do
+      profiler = lambda {|*args, &app|
+        app.call
+        :profiler_response
+      }
+
+      response = Pilfer::Profiler.new(reporter).profile(profiler) {
+        :app_response
+      }
+
+      response.should eq(:app_response)
+    end
+
+    it 'writes profile to reporter' do
+      profiler = stub(:profiler, :call => :profiler_response)
+      reporter.should_receive(:write).with(:profiler_response, start)
+      Pilfer::Profiler.new(reporter).profile(profiler, start) { }
+    end
+  end
+
+  describe '#profile_files_matching' do
+    let(:matcher) { stub(:matcher) }
+
+    it 'passes file matcher to profiler' do
+      profiler = stub(:profiler)
+      profiler.should_receive(:call).with(matcher)
+      Pilfer::Profiler.new(reporter).
+        profile_files_matching(matcher, profiler) { }
+    end
+
+    it 'writes profile to reporter' do
+      profiler = stub(:profiler, :call => :profiler_response)
+      reporter.should_receive(:write).with(:profiler_response, start)
+      Pilfer::Profiler.new(reporter).
+        profile_files_matching(matcher, profiler, start) { }
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pilfer
 version: !ruby/object:Gem::Version
-  version: 0.0.1.pre3
+  version: 0.0.1.pre4
 platform: ruby
 authors:
 - Eric Lindvall
@@ -9,85 +9,42 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-17 00:00:00.000000000 Z
+date: 2013-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rblineprof
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :development
+        version: 0.3.2
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: 0.3.2
 - !ruby/object:Gem::Dependency
-  name: rspec
-  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: rake
-  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: rack
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.5.2
+        version: '1.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.5.2
-- !ruby/object:Gem::Dependency
-  name: debugger-ruby_core_source
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.0'
 description: 
 email:
 - eric@sevenscale.com
 - larry@marburger.cc
 executables: []
-extensions:
-- ext/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
 - Gemfile
@@ -95,13 +52,19 @@ files:
 - README.md
 - pilfer.gemspec
 - lib/pilfer/logger.rb
+- lib/pilfer/middleware.rb
 - lib/pilfer/profile.rb
 - lib/pilfer/profiler.rb
 - lib/pilfer/version.rb
+- spec/files/hello.rb
+- spec/files/test.rb
+- spec/helper.rb
+- spec/pilfer/logger_spec.rb
+- spec/pilfer/middleware_spec.rb
+- spec/pilfer/profile_spec.rb
+- spec/pilfer/profiler_spec.rb
 - script/package
 - script/release
-- ext/extconf.rb
-- ext/rblineprof.c
 homepage: https://github.com/eric/pilfer
 licenses:
 - MIT
@@ -126,4 +89,11 @@ rubygems_version: 2.0.3
 signing_key: 
 specification_version: 4
 summary: Look into your ruby with rblineprof
-test_files: []
+test_files:
+- spec/files/hello.rb
+- spec/files/test.rb
+- spec/helper.rb
+- spec/pilfer/logger_spec.rb
+- spec/pilfer/middleware_spec.rb
+- spec/pilfer/profile_spec.rb
+- spec/pilfer/profiler_spec.rb

data/ext/extconf.rb

@@ -1,19 +0,0 @@
-require 'mkmf'
-
-if RUBY_VERSION >= "1.9"
-  require "debugger/ruby_core_source"
-
-  hdrs = proc {
-    have_type("rb_iseq_location_t", "vm_core.h")
-
-    have_header("vm_core.h") and
-    have_header("iseq.h")
-  }
-
-  unless Debugger::RubyCoreSource::create_makefile_with_core(hdrs, "rblineprof")
-    STDERR.puts "\nDebugger::RubyCoreSource::create_makefile failed"
-    exit(1)
-  end
-else
-  create_makefile 'rblineprof'
-end

data/ext/rblineprof.c

@@ -1,619 +0,0 @@
-#include <ruby.h>
-#include <stdbool.h>
-#include <time.h>
-#include <sys/time.h>
-#include <sys/resource.h>
-
-#ifdef RUBY_VM
-  #include <ruby/re.h>
-  #include <ruby/intern.h>
-  #include <vm_core.h>
-  #include <iseq.h>
-
-  // There's a compile error on 1.9.3. So:
-  #ifdef RTYPEDDATA_DATA
-  #define ruby_current_thread ((rb_thread_t *)RTYPEDDATA_DATA(rb_thread_current()))
-  #endif
-#else
-  #include <st.h>
-  #include <re.h>
-  #include <intern.h>
-  #include <node.h>
-  #include <env.h>
-  typedef rb_event_t rb_event_flag_t;
-#endif
-
-static VALUE gc_hook;
-
-/*
- * Time in microseconds
- */
-typedef uint64_t prof_time_t;
-
-/*
- * Profiling snapshot
- */
-typedef struct snapshot {
-  prof_time_t wall_time;
-  prof_time_t cpu_time;
-} snapshot_t;
-
-/*
- * A line of Ruby source code
- */
-typedef struct sourceline {
-  uint64_t calls; // total number of call/c_call events
-  snapshot_t total;
-} sourceline_t;
-
-/*
- * Struct representing a single Ruby file.
- */
-typedef struct sourcefile {
-  char *filename;
-
-  /* per line timing */
-  long nlines;
-  sourceline_t *lines;
-
-  /* overall file timing */
-  snapshot_t total;
-  snapshot_t child;
-  uint64_t depth;
-  snapshot_t exclusive_start;
-  snapshot_t exclusive;
-} sourcefile_t;
-
-/*
- * An individual stack frame used to track
- * calls and returns from Ruby methods
- */
-typedef struct stackframe {
-  // data emitted from Ruby to our profiler hook
-  rb_event_flag_t event;
-#ifdef RUBY_VM
-  rb_thread_t *thread;
-#else
-  NODE *node;
-#endif
-  VALUE self;
-  ID mid;
-  VALUE klass;
-
-  char *filename;
-  long line;
-
-  snapshot_t start;
-  sourcefile_t *srcfile;
-} stackframe_t;
-
-/*
- * Static properties and rbineprof configuration
- */
-static struct {
-  bool enabled;
-
-  // stack
-  #define MAX_STACK_DEPTH 32768
-  stackframe_t stack[MAX_STACK_DEPTH];
-  uint64_t stack_depth;
-
-  // single file mode, store filename and line data directly
-  char *source_filename;
-  sourcefile_t file;
-
-  // regex mode, store file data in hash table
-  VALUE source_regex;
-  st_table *files;
-
-  // cache
-  struct {
-    char *file;
-    sourcefile_t *srcfile;
-  } cache;
-}
-rblineprof = {
-  .enabled = false,
-  .source_regex = Qfalse
-};
-
-static prof_time_t
-cputime_usec()
-{
-#if defined(__linux__)
-  struct timespec ts;
-
-  if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) == 0) {
-    return (prof_time_t)ts.tv_sec*1e6 +
-           (prof_time_t)ts.tv_nsec*1e-3;
-  }
-#endif
-
-#if defined(RUSAGE_SELF)
-  struct rusage usage;
-
-  getrusage(RUSAGE_SELF, &usage);
-  return (prof_time_t)usage.ru_utime.tv_sec*1e6 +
-         (prof_time_t)usage.ru_utime.tv_usec;
-#endif
-
-  return 0;
-}
-
-static prof_time_t
-walltime_usec()
-{
-  struct timeval tv;
-  gettimeofday(&tv, NULL);
-  return (prof_time_t)tv.tv_sec*1e6 +
-         (prof_time_t)tv.tv_usec;
-}
-
-static inline snapshot_t
-snapshot_diff(snapshot_t *t1, snapshot_t *t2)
-{
-  snapshot_t diff = {
-    .wall_time         = t1->wall_time - t2->wall_time,
-    .cpu_time          = t1->cpu_time  - t2->cpu_time,
-  };
-
-  return diff;
-}
-
-static inline void
-snapshot_increment(snapshot_t *s, snapshot_t *inc)
-{
-  s->wall_time         += inc->wall_time;
-  s->cpu_time          += inc->cpu_time;
-}
-
-static inline void
-stackframe_record(stackframe_t *frame, snapshot_t now, stackframe_t *caller_frame)
-{
-  sourcefile_t *srcfile = frame->srcfile;
-  long line = frame->line;
-
-  /* allocate space for per-line data the first time */
-  if (srcfile->lines == NULL) {
-    srcfile->nlines = line + 100;
-    srcfile->lines = ALLOC_N(sourceline_t, srcfile->nlines);
-    MEMZERO(srcfile->lines, sourceline_t, srcfile->nlines);
-  }
-
-  /* grow the per-line array if necessary */
-  if (line >= srcfile->nlines) {
-    long prev_nlines = srcfile->nlines;
-    srcfile->nlines = line + 100;
-
-    REALLOC_N(srcfile->lines, sourceline_t, srcfile->nlines);
-    MEMZERO(srcfile->lines + prev_nlines, sourceline_t, srcfile->nlines - prev_nlines);
-  }
-
-  snapshot_t diff = snapshot_diff(&now, &frame->start);
-  sourceline_t *srcline = &(srcfile->lines[line]);
-
-  /* Line profiler metrics.
-   */
-
-  srcline->calls++;
-
-  /* Increment current line's total_time.
-   *
-   * Skip the special case where the stack frame we're returning to
-   * had the same file/line. This fixes double counting on crazy one-liners.
-   */
-  if (!(caller_frame && caller_frame->srcfile == frame->srcfile && caller_frame->line == frame->line))
-    snapshot_increment(&srcline->total, &diff);
-
-  /* File profiler metrics.
-   */
-
-  /* Increment the caller file's child_time.
-   */
-  if (caller_frame && caller_frame->srcfile != srcfile)
-    snapshot_increment(&caller_frame->srcfile->child, &diff);
-
-  /* Increment current file's total_time, but only when we return
-   * to the outermost stack frame when we first entered the file.
-   */
-  if (srcfile->depth == 0)
-    snapshot_increment(&srcfile->total, &diff);
-}
-
-static inline sourcefile_t*
-sourcefile_lookup(char *filename)
-{
-  sourcefile_t *srcfile = NULL;
-
-  if (rblineprof.source_filename) { // single file mode
-#ifdef RUBY_VM
-    if (strcmp(rblineprof.source_filename, filename) == 0) {
-#else
-    if (rblineprof.source_filename == filename) { // compare char*, not contents
-#endif
-      srcfile = &rblineprof.file;
-      srcfile->filename = filename;
-    } else {
-      return NULL;
-    }
-
-  } else { // regex mode
-    st_lookup(rblineprof.files, (st_data_t)filename, (st_data_t *)&srcfile);
-
-    if ((VALUE)srcfile == Qnil) // known negative match, skip
-      return NULL;
-
-    if (!srcfile) { // unknown file, check against regex
-      VALUE backref = rb_backref_get();
-      rb_match_busy(backref);
-      long rc = rb_reg_search(rblineprof.source_regex, rb_str_new2(filename), 0, 0);
-      rb_backref_set(backref);
-
-      if (rc >= 0) {
-        srcfile = ALLOC_N(sourcefile_t, 1);
-        MEMZERO(srcfile, sourcefile_t, 1);
-        srcfile->filename = strdup(filename);
-        st_insert(rblineprof.files, (st_data_t)srcfile->filename, (st_data_t)srcfile);
-      } else { // no match, insert Qnil to prevent regex next time
-        st_insert(rblineprof.files, (st_data_t)strdup(filename), (st_data_t)Qnil);
-        return NULL;
-      }
-    }
-  }
-
-  return srcfile;
-}
-
-#ifdef RUBY_VM
-/* Find the source of the current method call. This is based on rb_f_caller
- * in vm_eval.c, and replicates the behavior of `caller.first` from ruby.
- *
- * On method calls, ruby 1.9 sends an extra RUBY_EVENT_CALL event with mid=0. The
- * top-most cfp on the stack in these cases points to the 'def method' line, so we skip
- * these and grab the second caller instead.
- */
-static inline
-rb_control_frame_t *
-rb_vm_get_caller(rb_thread_t *th, rb_control_frame_t *cfp, ID mid)
-{
-  int level = 0;
-
-  while (!RUBY_VM_CONTROL_FRAME_STACK_OVERFLOW_P(th, cfp)) {
-    if (++level == 1 && mid == 0) {
-      // skip method definition line
-    } else if (cfp->iseq != 0 && cfp->pc != 0) {
-      return cfp;
-    }
-
-    cfp = RUBY_VM_PREVIOUS_CONTROL_FRAME(cfp);
-  }
-
-  return 0;
-}
-
-#ifdef HAVE_TYPE_RB_ISEQ_LOCATION_T
-inline static int
-calc_lineno(const rb_iseq_t *iseq, const VALUE *pc)
-{
-  return rb_iseq_line_no(iseq, pc - iseq->iseq_encoded);
-}
-
-int
-rb_vm_get_sourceline(const rb_control_frame_t *cfp)
-{
-  int lineno = 0;
-  const rb_iseq_t *iseq = cfp->iseq;
-
-  if (RUBY_VM_NORMAL_ISEQ_P(iseq)) {
-    lineno = calc_lineno(cfp->iseq, cfp->pc);
-  }
-  return lineno;
-}
-#endif
-#endif
-
-static void
-#ifdef RUBY_VM
-profiler_hook(rb_event_flag_t event, VALUE data, VALUE self, ID mid, VALUE klass)
-#else
-profiler_hook(rb_event_flag_t event, NODE *node, VALUE self, ID mid, VALUE klass)
-#endif
-{
-  char *file;
-  long line;
-  stackframe_t *frame = NULL, *prev = NULL;
-  sourcefile_t *srcfile;
-
-  /* line profiler: maintain a stack of CALL events with timestamps. for
-   * each corresponding RETURN, account elapsed time to the calling line.
-   *
-   * we use ruby_current_node here to get the caller's file/line info,
-   * (as opposed to node, which points to the callee method being invoked)
-   */
-#ifndef RUBY_VM
-  NODE *caller_node = ruby_frame->node;
-  if (!caller_node) return;
-
-  file = caller_node->nd_file;
-  line = nd_line(caller_node);
-#else
-  rb_thread_t *th = ruby_current_thread;
-  rb_control_frame_t *cfp = rb_vm_get_caller(th, th->cfp, mid);
-  if (!cfp) return;
-
-  #ifdef HAVE_TYPE_RB_ISEQ_LOCATION_T
-    if (RTEST(cfp->iseq->location.absolute_path))
-      file = StringValueCStr(cfp->iseq->location.absolute_path);
-    else
-      file = StringValueCStr(cfp->iseq->location.path);
-  #else
-    if (RTEST(cfp->iseq->filepath))
-      file = StringValueCStr(cfp->iseq->filepath);
-    else
-      file = StringValueCStr(cfp->iseq->filename);
-  #endif
-  line = rb_vm_get_sourceline(cfp);
-#endif
-
-  if (!file) return;
-  if (line <= 0) return;
-
-  /* find the srcfile entry for the current file.
-   *
-   * first check the cache, in case this is the same file as
-   * the previous invocation.
-   *
-   * if no record is found, we don't care about profiling this
-   * file and return early.
-   */
-  if (rblineprof.cache.file == file)
-    srcfile = rblineprof.cache.srcfile;
-  else
-    srcfile = sourcefile_lookup(file);
-  rblineprof.cache.file = file;
-  rblineprof.cache.srcfile = srcfile;
-  if (!srcfile) return; /* skip line profiling for this file */
-
-  snapshot_t now = {
-    .wall_time         = walltime_usec(),
-    .cpu_time          = cputime_usec(),
-  };
-
-  switch (event) {
-    case RUBY_EVENT_CALL:
-    case RUBY_EVENT_C_CALL:
-      /* Create a stack frame entry with this event,
-       * the current file, and a snapshot of metrics.
-       *
-       * On a corresponding RETURN event later, we can
-       * pop this stack frame and accumulate metrics to the
-       * associated file and line.
-       */
-      rblineprof.stack_depth++;
-      if (rblineprof.stack_depth > 0 && rblineprof.stack_depth < MAX_STACK_DEPTH) {
-        frame = &rblineprof.stack[rblineprof.stack_depth-1];
-        frame->event = event;
-        frame->self = self;
-        frame->mid = mid;
-        frame->klass = klass;
-        frame->line = line;
-        frame->start = now;
-        frame->srcfile = srcfile;
-#ifdef RUBY_VM
-        frame->thread = th;
-#else
-        frame->node = node;
-#endif
-      }
-
-      /* Record when we entered this file for the first time.
-       * The difference is later accumulated into exclusive_time,
-       * e.g. on the next event if the file changes.
-       */
-      if (srcfile->depth == 0)
-        srcfile->exclusive_start = now;
-      srcfile->depth++;
-
-      if (rblineprof.stack_depth > 1) { // skip if outermost frame
-        prev = &rblineprof.stack[rblineprof.stack_depth-2];
-
-        /* If we just switched files, record time that was spent in
-         * the previous file.
-         */
-        if (prev->srcfile != frame->srcfile) {
-          snapshot_t diff = snapshot_diff(&now, &prev->srcfile->exclusive_start);
-          snapshot_increment(&prev->srcfile->exclusive, &diff);
-          prev->srcfile->exclusive_start = now;
-        }
-      }
-      break;
-
-    case RUBY_EVENT_RETURN:
-    case RUBY_EVENT_C_RETURN:
-      /* Find the corresponding CALL for this event.
-       *
-       * We loop here instead of a simple pop, because in the event of a
-       * raise/rescue several stack frames could have disappeared.
-       */
-      do {
-        if (rblineprof.stack_depth > 0 && rblineprof.stack_depth < MAX_STACK_DEPTH) {
-          frame = &rblineprof.stack[rblineprof.stack_depth-1];
-          if (frame->srcfile->depth > 0)
-            frame->srcfile->depth--;
-        } else
-          frame = NULL;
-
-        rblineprof.stack_depth--;
-      } while (frame &&
-#ifdef RUBY_VM
-               frame->thread != th &&
-#endif
-               /* Break when we find a matching CALL/C_CALL.
-                */
-               frame->event != (event == RUBY_EVENT_CALL ? RUBY_EVENT_RETURN : RUBY_EVENT_C_RETURN) &&
-               frame->self != self &&
-               frame->mid != mid &&
-               frame->klass != klass);
-
-      if (rblineprof.stack_depth > 0) {
-        // The new top of the stack (that we're returning to)
-        prev = &rblineprof.stack[rblineprof.stack_depth-1];
-
-        /* If we're leaving this frame to go back to a different file,
-         * accumulate time we spent in this file.
-         *
-         * Note that we do this both when entering a new file and leaving to
-         * a new file to ensure we only count time spent exclusively in that file.
-         * Consider the following scenario:
-         *
-         *     call (a.rb:1)
-         *       call (b.rb:1)         <-- leaving a.rb, increment into exclusive_time
-         *         call (a.rb:5)
-         *         return              <-- leaving a.rb, increment into exclusive_time
-         *       return
-         *     return
-         */
-        if (frame->srcfile != prev->srcfile) {
-          snapshot_t diff = snapshot_diff(&now, &frame->srcfile->exclusive_start);
-          snapshot_increment(&frame->srcfile->exclusive, &diff);
-          frame->srcfile->exclusive_start = now;
-          prev->srcfile->exclusive_start = now;
-        }
-      }
-
-      if (frame)
-        stackframe_record(frame, now, prev);
-
-      break;
-  }
-}
-
-static int
-cleanup_files(st_data_t key, st_data_t record, st_data_t arg)
-{
-  xfree((char *)key);
-
-  sourcefile_t *sourcefile = (sourcefile_t*)record;
-  if (!sourcefile || (VALUE)sourcefile == Qnil) return ST_DELETE;
-
-  if (sourcefile->lines)
-    xfree(sourcefile->lines);
-  xfree(sourcefile);
-
-  return ST_DELETE;
-}
-
-static int
-summarize_files(st_data_t key, st_data_t record, st_data_t arg)
-{
-  sourcefile_t *srcfile = (sourcefile_t*)record;
-  if (!srcfile || (VALUE)srcfile == Qnil) return ST_CONTINUE;
-
-  VALUE ret = (VALUE)arg;
-  VALUE ary = rb_ary_new();
-  long i;
-
-  rb_ary_store(ary, 0, rb_ary_new3(6,
-    ULL2NUM(srcfile->total.wall_time),
-    ULL2NUM(srcfile->child.wall_time),
-    ULL2NUM(srcfile->exclusive.wall_time),
-    ULL2NUM(srcfile->total.cpu_time),
-    ULL2NUM(srcfile->child.cpu_time),
-    ULL2NUM(srcfile->exclusive.cpu_time)
-  ));
-
-  for (i=1; i<srcfile->nlines; i++)
-    rb_ary_store(ary, i, rb_ary_new3(3,
-      ULL2NUM(srcfile->lines[i].total.wall_time),
-      ULL2NUM(srcfile->lines[i].total.cpu_time),
-      ULL2NUM(srcfile->lines[i].calls)
-    ));
-  rb_hash_aset(ret, rb_str_new2(srcfile->filename), ary);
-
-  return ST_CONTINUE;
-}
-
-static VALUE
-lineprof_ensure(VALUE self)
-{
-  rb_remove_event_hook((rb_event_hook_func_t) profiler_hook);
-  rblineprof.enabled = false;
-  return self;
-}
-
-VALUE
-lineprof(VALUE self, VALUE filename)
-{
-  if (!rb_block_given_p())
-    rb_raise(rb_eArgError, "block required");
-
-  if (rblineprof.enabled)
-    rb_raise(rb_eArgError, "profiler is already enabled");
-
-  VALUE filename_class = rb_obj_class(filename);
-
-  if (filename_class == rb_cString) {
-#ifdef RUBY_VM
-    rblineprof.source_filename = (char *) (StringValuePtr(filename));
-#else
-    /* rb_source_filename will return a string we can compare directly against
-     * node->file, without a strcmp()
-     */
-    rblineprof.source_filename = rb_source_filename(StringValuePtr(filename));
-#endif
-  } else if (filename_class == rb_cRegexp) {
-    rblineprof.source_regex = filename;
-    rblineprof.source_filename = NULL;
-  } else {
-    rb_raise(rb_eArgError, "argument must be String or Regexp");
-  }
-
-  // reset state
-  st_foreach(rblineprof.files, cleanup_files, 0);
-  if (rblineprof.file.lines) {
-    xfree(rblineprof.file.lines);
-    rblineprof.file.lines = NULL;
-    rblineprof.file.nlines = 0;
-  }
-  rblineprof.cache.file = NULL;
-  rblineprof.cache.srcfile = NULL;
-
-  rblineprof.enabled = true;
-#ifndef RUBY_VM
-  rb_add_event_hook((rb_event_hook_func_t) profiler_hook, RUBY_EVENT_CALL|RUBY_EVENT_RETURN|RUBY_EVENT_C_CALL|RUBY_EVENT_C_RETURN);
-#else
-  rb_add_event_hook((rb_event_hook_func_t) profiler_hook, RUBY_EVENT_CALL|RUBY_EVENT_RETURN|RUBY_EVENT_C_CALL|RUBY_EVENT_C_RETURN, Qnil);
-#endif
-
-  rb_ensure(rb_yield, Qnil, lineprof_ensure, self);
-
-  VALUE ret = rb_hash_new();
-  VALUE ary = Qnil;
-
-  if (rblineprof.source_filename) {
-    summarize_files(Qnil, (st_data_t)&rblineprof.file, ret);
-  } else {
-    st_foreach(rblineprof.files, summarize_files, ret);
-  }
-
-  return ret;
-}
-
-static void
-rblineprof_gc_mark()
-{
-  if (rblineprof.enabled)
-    rb_gc_mark_maybe(rblineprof.source_regex);
-}
-
-void
-Init_rblineprof()
-{
-  gc_hook = Data_Wrap_Struct(rb_cObject, rblineprof_gc_mark, NULL, NULL);
-  rb_global_variable(&gc_hook);
-
-  rblineprof.files = st_init_strtable();
-  rb_define_global_function("lineprof", lineprof, 1);
-}
-
-/* vim: set ts=2 sw=2 expandtab: */