active-profiling 0.0.1

data/.gitignore

@@ -0,0 +1,14 @@
+*.orig
+.*.swp
+.*.swo
+*.tmp
+*~
+.DS_Store
+*tmp*
+pkg/
+doc/
+*.orig
+*.patch
+*.rbc
+.rbx
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,4 @@
+
+source "http://rubygems.org"
+
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 J Smith <dark.panda@gmail.com>
+
+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.rdoc

@@ -0,0 +1,124 @@
+
+= ActiveProfiling
+
+ActiveProfiling is a gem I've slapped together over the years to help with
+profiling Rails applications. It is mostly aimed at profiling actions but
+can also be used to profile generic blocks of code.
+
+== Profiler ActionController Filters
+
+=== +action_profiler+
+
+This filter wraps up the functionality of RubyProf for each action and can be
+used to spit out the results to +stdout+, your log file or to files in the
++Rails.root/log/profiling+ directory.
+
+Options and their defaults for +action_profiler+ are listed in
+ActiveProfiling::Railtie::DEFAULT_PROFILER_OPTIONS, but the gist of it is that
+you can basically use any of RubyProf's various options and control where the
+output is directed. For some the +:call_tree+ output type, results are written
+to individual files in +Rails.root/log/profiling+, while for all other output
+types the results are written to the Rails log. You can of course redirect
+all logging to files if you prefer, or to the standard output.
+
+To enable this filter, add the following to your application configuration:
+
+  config.active_profiling.profiler.enabled = true
+
+=== +action_gc_statistics+
+
+This filter wraps up the functionality of either GC::Profiler in Ruby 1.9+ or
+the GC statistics patches available for 1.8.7 if installed, either through
+Ruby Enterprise Edition or by patching your own Ruby. When enabled, information
+on the Ruby garbage collector will be written to the Rails log at the end of
+each action response. Options for controlling how the information is collected
+and logged can be found in ActiveProfiling::Railtie::DEFAULT_GC_STATISTICS_OPTIONS.
+
+Note that the output for Ruby 1.9+ is a bit different from REE or a patched
+Ruby due to the manner in which they collect and report on GC statistics. In
+the REE patches you can access a number of options that aren't currently
+available in GC::Profiler. I've tried to make some sensible output for REE,
+but there are going to be differences based solely on the manner in which the
+statistics are collected.
+
+To enable this filter, add the following to your application configuration:
+
+  config.active_profiling.gc_statistics.enabled = true
+
+== Profiling Blocks
+
+You can also profile individual blocks of code by using the
+ActiveProfiling.ruby_profiler and ActiveProfiling.gc_statistics methods or
+by including the ActiveProfiling::RubyProfiler or ActiveProfiling::GCStatistics
+modules and using the methods in your own classes and modules. In both cases,
+these methods take the same options as found in the ActionController filters
+minus the +:enabled+ option.
+
+  # Will spit out the GC statistics if GC is run, same as with the action
+  # filter.
+  ActiveProfiling.gc_statistics do
+    # ...
+  end
+
+  # Wraps the block in a RubyProf session and logs the results accordingly.
+  ActiveProfiling.ruby_profiler(options) do
+    # ...
+  end
+
+== Using In A Rails Project
+
+Profiling should be performed in a production environment, as profiling in
+development really isn't reflective of how your application is actually going
+to be running in the Real World. At the same time, you don't necessarily want
+to clutter up your application settings and +Gemfile+ with unnecessary code
+and have to worry about accidentally committing profiling settings to your
+source code repository and the like.
+
+A semi-neat trick to try is to set up a file for local application settings
+thusly:
+
+First, add the following to your +application.rb+. You generally want this near
+the end of the file.
+
+  if File.exists?("#{Rails.root}/config/application_local.rb")
+    require "#{Rails.root}/config/application_local.rb"
+  end
+
+Add an entry for +application_local.rb+ to your +.gitignore+ file or otherwise
+ignore it with your SCM.
+
+In +application_local.rb+, you can set up additional application settings
+like so:
+
+  Bundler.require(:profiling, Rails.env) if defined?(Bundler)
+
+  module FooBarApp
+    class Application < Rails::Application
+      # config.log_level = :debug
+      config.active_profiling.profiler.enabled = false
+      config.active_profiling.profiler.output = :file
+      config.active_profiling.profiler.printer = :graph_html
+      config.active_profiling.profiler.printer_options = {
+        :min_percent => 1,
+        :print_file => true
+      }
+      config.active_profiling.gc_statistics.enabled = true
+
+      # etc...
+    end
+  end
+
+This allows you to tweak some settings without affecting your main
++application.rb+ file.
+
+You'll also want to add the following to your +Gemfile+:
+
+  group :profiling do
+    gem 'active-profiling'
+    gem 'ruby-prof'
+  end
+
+== License
+
+This gem is licensed under an MIT-style license. See the +MIT-LICENSE+ file for
+details.

data/Rakefile

@@ -0,0 +1,39 @@
+
+# -*- ruby -*-
+
+require 'rubygems'
+
+gem 'rdoc', '~> 3.12'
+
+require 'rubygems/package_task'
+require 'rake/testtask'
+require 'rdoc/task'
+require 'bundler/gem_tasks'
+
+if RUBY_VERSION >= '1.9'
+  begin
+    gem 'psych'
+  rescue Exception => e
+    # it's okay, fall back on the bundled psych
+  end
+end
+
+$:.push 'lib'
+
+version = ActiveProfiling::VERSION
+
+desc 'Test ActiveProfiling interface'
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/**/*_tests.rb']
+  t.verbose = !!ENV['VERBOSE_TESTS']
+  t.warning = !!ENV['WARNINGS']
+end
+
+desc 'Build docs'
+Rake::RDocTask.new do |t|
+  t.title = "ActiveProfiling #{version}"
+  t.main = 'README.rdoc'
+  t.rdoc_dir = 'doc'
+  t.rdoc_files.include('README.rdoc', 'MIT-LICENSE', 'lib/**/*.rb')
+end
+

data/active-profiling.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/active-profiling/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name = "active-profiling"
+  s.version = ActiveProfiling::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["J Smith"]
+  s.description = "A Rails profiling suite."
+  s.summary = s.description
+  s.email = "dark.panda@gmail.com"
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = `git ls-files`.split($\)
+  s.executables = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
+  s.test_files = s.files.grep(%r{^(test|spec|features)/})
+  s.homepage = "http://github.com/dark-panda/active-profiling"
+  s.require_paths = ["lib"]
+
+  s.add_dependency("rails", [">= 3.0"])
+  s.add_dependency("rdoc")
+  s.add_dependency("rake", ["~> 0.9"])
+end
+

data/lib/active-profiling.rb

@@ -0,0 +1,26 @@
+
+module ActiveProfiling
+  class << self
+    def gc_statistics?
+      if defined?(@has_gc_statistics)
+        @has_gc_statistics
+      else
+        @has_gc_statistics = defined?(GC::Profiler) || GC.respond_to?(:enable_stats)
+      end
+    end
+
+    def ruby_prof?
+      if defined?(@has_ruby_prof)
+        @has_ruby_prof
+      else
+        @has_ruby_prof = defined?(RubyProf)
+      end
+    end
+  end
+end
+
+require 'active-profiling/railtie'
+require 'active-profiling/log_subscriber'
+require 'active-profiling/gc_statistics'
+require 'active-profiling/ruby_profiler'
+require 'active-profiling/action_controller/action_profiling'

data/lib/active-profiling/action_controller/action_profiling.rb

@@ -0,0 +1,37 @@
+
+require 'digest/md5'
+
+module ActionController
+  module ActionProfiling
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveProfiling::RubyProfiler
+      include ActiveProfiling::GCStatistics
+
+      around_filter :action_profiler, :if => proc {
+        Rails.application.config.active_profiling.profiler.enabled && ActiveProfiling.ruby_prof?
+      }
+
+      around_filter :action_gc_statistics, :if => proc {
+        Rails.application.config.active_profiling.gc_statistics.enabled && ActiveProfiling.gc_statistics?
+      }
+    end
+
+    def action_profiler(*args)
+      ruby_profiler do
+        yield
+      end
+    end
+
+    def action_gc_statistics(*args)
+      gc_statistics do
+        yield
+      end
+    end
+  end
+
+  class Base
+    include ActionController::ActionProfiling
+  end
+end

data/lib/active-profiling/gc_statistics.rb

@@ -0,0 +1,105 @@
+
+module ActiveProfiling
+  module GCStatistics
+    extend ActiveSupport::Concern
+
+    if defined?(GC::Profiler)
+      def gc_statistics_report(options = {})
+        options = {
+          :disable_gc => false
+        }.merge(options)
+
+        GC.disable if options[:disable_gc]
+        GC::Profiler.enable
+        GC::Profiler.clear
+
+        retval = yield
+
+        if options[:disable_gc]
+          GC.enable
+        end
+
+        result = GC::Profiler.result
+
+        return [ retval, result ]
+
+      ensure
+        GC.enable if options[:disable_gc]
+        GC::Profiler.disable
+        GC::Profiler.clear
+      end
+    elsif GC.respond_to?(:enable_stats)
+      def gc_statistics_report(options = {})
+        options = {
+          :disable_gc => false
+        }.merge(options)
+
+        GC.disable if options[:disable_gc]
+        GC.enable_stats
+        GC.clear_stats
+
+        retval = yield
+
+        result = [
+          "Allocated size: #{GC.allocated_size}",
+          "Number of allocations: #{GC.num_allocations}",
+          "Collections: #{GC.collections}",
+          "Time (ms): #{GC.time / 1000.0}"
+        ].join("\n")
+
+        return [ retval, result ]
+
+      ensure
+        GC.enable if options[:disable_gc]
+        GC.disable_stats
+        GC.clear_stats
+      end
+    else
+      $stderr.puts "NOTICE: this version of Ruby cannot report on GC statistics."
+
+      def gc_statistics_report(*args)
+        [ yield, nil ]
+      end
+    end
+
+    private :gc_statistics_report
+
+    # Profiles a block, capturing information on the garbage collector. The
+    # return value is an Array containing the result of the yielded block
+    # and a String with a report on the profiling results.
+    #
+    # Options:
+    #
+    # * +:disable_gc+ - disables garbage collection for the duration of the
+    #   block and then renables it immediately afterwards. This allows you to
+    #   control when GC is run and see the results.
+    # * +:title+ - a title to use for logging.
+    #
+    # More options for this method can be found in the default settings,
+    # located in ActiveProfiling::Railtie::DEFAULT_GC_STATISTICS_OPTIONS.
+    #
+    # This method only works with versions of Ruby that implement
+    # GC::Profiler or that have been patched to implement some additional
+    # garbage collection statistics. In older versions, such as version
+    # 1.8.7, you can either use Ruby Enterprise Edition or patch your build
+    # with the GC statistics patch found here:
+    #
+    # http://blog.pluron.com/2008/02/memory-profilin.html
+    def gc_statistics(*args)
+      options = Rails.application.config.active_profiling.gc_statistics.merge(args.extract_options!)
+
+      result, gc_report = gc_statistics_report(options) do
+        yield
+      end
+
+      ActiveSupport::Notifications.instrument('gc_statistics.active_profiling', {
+        :report => gc_report,
+        :title => options[:title] || args.first
+      })
+
+      result
+    end
+  end
+
+  self.extend(GCStatistics)
+end

data/lib/active-profiling/log_subscriber.rb

@@ -0,0 +1,58 @@
+
+module ActiveProfiling
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def profiler_output(event)
+      return unless logger &&
+        logger.send("#{config.profiler.log_level}?")
+
+      report = self.indent(event.payload[:profiler_output])
+
+      logger.send(
+        config.profiler.log_level,
+        "#{color("Profiler Output", YELLOW, true)}\n#{report}"
+      )
+    end
+
+    def profiler_output_to_file(event)
+      return unless logger &&
+        logger.send("#{config.profiler.log_level}?")
+
+      logger.send(
+        config.profiler.log_level,
+        color("Wrote profiling information to #{event.payload[:file_name]}", YELLOW, true)
+      )
+    end
+
+    def gc_statistics(event)
+      return unless logger &&
+        logger.send("#{config.gc_statistics.log_level}?")
+
+      unless event.payload[:report].blank?
+        title = event.payload[:title]
+        report = self.indent(event.payload[:report])
+
+        logger.send(
+          config.gc_statistics.log_level,
+          "#{color("GC Statistics: #{title}", YELLOW, true)}\n#{report}"
+        )
+      end
+    end
+
+    def logger
+      ::Rails.logger
+    end
+
+    protected
+      def config
+        Rails.application.config.active_profiling
+      end
+
+      def indent(text)
+        text.split("\n").collect { |line|
+          "  #{line}"
+        }.join("\n")
+      end
+  end
+end
+
+ActiveProfiling::LogSubscriber.attach_to :active_profiling

data/lib/active-profiling/railtie.rb

@@ -0,0 +1,98 @@
+
+module ActiveProfiling
+  class Railtie < Rails::Railtie
+    # These settings are the default values used when running RubyProf on
+    # every request. You can also use the profiler directly by using the
+    # ActiveProfiling.ruby_profiler method.
+    #
+    # * +:enabled+ - Enable profiler on requests.
+    # * +:measure_mode+ - The ruby-prof measure mode. The default is
+    #   RubyProf::PROCESS_TIME. Use Symbols for this instead of the actual
+    #   RubyProf constants (i.e. +:memory+ instead of RubyProf::MEMORY) so
+    #   you can have your configuration options in your environment set up
+    #   without having to require ruby-prof.
+    # * +:disable_gc+ - Whether or not we're disabling garbage collection
+    #   during profiling. This is useful when you're profiling memory usage,
+    #   where you should disable garbage collection as ruby-prof will
+    #   otherwise record information on GC on the method that causes GC rather
+    #   than the methods that allocate the memory.
+    # * +:printer+ - The RubyProf printer to use. See the RubyProf docs for
+    #   details. The default is RubyProf::FlatPrinter. Use Symbols in this
+    #   option, i.e. +:flat+ instead of RubyProf::FlatPrinter. (Note that the
+    #   FlatPrinterWithLineNumbers printer is called +:flat_with_line_numbers+
+    #   here.)
+    # * +:call_tree_prefix+ - The prefix to use for +:call_tree+ files. Some
+    #   programs like to look for files named "callgrind.out.*", while others
+    #   like to look for "cachegrind.out.*".
+    # * +:output+ - Where to direct the output from the profiler. If set to
+    #   +:stdout+, well, then it's sent to $stdout. When set to +:log+, it
+    #   shows up in the log file. When set to +:file+, it gets put in
+    #   +Rails.root/log/profiling/+ in a sensible manner. The default depends
+    #   on the +:printer+ being used:
+    #
+    #   * +:file+ - +:graph_html+, +:call_stack+, +:call_tree+, +:dot+
+    #   * +:log+ - +:flat+, +:flat_with_line_numbers+, +:graph+ and anything
+    #     else
+    # * +:log_level+ - The log level to spit the logging information into
+    #   when using +:log+ for +:output+. The default is +:info+.
+    # * +:printer_options+ - Options to pass to the profiler printer. The
+    #   default is:
+    #
+    #     :printer_options => {
+    #       :min_percent => 1,
+    #       :print_file => true
+    #     }
+    DEFAULT_PROFILER_OPTIONS = {
+      :enabled => false,
+
+      :measure_mode => :process_time,
+
+      :disable_gc => true,
+
+      :printer => :graph,
+
+      :call_tree_prefix => 'callgrind.out.',
+
+      :output => nil,
+
+      :log_level => :info,
+
+      :printer_options => {
+        :min_percent => 1,
+        :print_file => true
+      }
+    }.freeze
+
+    # These settings are the default values used when profiling GC statistics.
+    # When enabled, statistics are gathered for every request. You can also
+    # gather statistics on a per-block basis using ActiveProfiling.gc_statistics
+    # directly.
+    #
+    # * +:enabled+ - For logging GC stats. Output is dumped into the log on
+    #   each request.
+    # * +:disable_gc+ - Whether or not we're disabling actual garbage
+    #   collection during statistics gathering. If set to true, the garbage
+    #   collector will be disabled for the duration of the action and then
+    #   re-enabled at the end of the action. This allows you to call GC.start
+    #   whenever you need to and see results as you go.
+    # * +:log_level+ - The log level to spit the GC statistics to.
+    DEFAULT_GC_STATISTICS_OPTIONS = {
+      :enabled => false,
+
+      :disable_gc => false,
+
+      :log_level => :info
+    }.freeze
+
+    config.active_profiling = ActiveSupport::OrderedOptions.new
+    config.active_profiling.profiler = ActiveSupport::OrderedOptions.new
+    config.active_profiling.gc_statistics = ActiveSupport::OrderedOptions.new
+
+    initializer "active_profiling.set_profiling_config" do |app|
+      options = app.config.active_profiling
+
+      options.profiler.reverse_merge!(DEFAULT_PROFILER_OPTIONS)
+      options.gc_statistics.reverse_merge!(DEFAULT_GC_STATISTICS_OPTIONS)
+    end
+  end
+end

data/lib/active-profiling/ruby_profiler.rb

@@ -0,0 +1,103 @@
+
+module ActiveProfiling
+  module RubyProfiler
+    extend ActiveSupport::Concern
+
+    # Runs a block of Ruby code through ruby-prof and returns the profiler
+    # output. Returns an Array containing the the result of the block yielded
+    # and the profiler data.
+    #
+    # For details on the various options, see the default options located in
+    # ActiveProfiling::Railtie::DEFAULT_PROFILER_OPTIONS.
+    def ruby_profiler(*args)
+      options = Rails.application.config.active_profiling.profiler.merge(args.extract_options!)
+
+      printer_class = case options[:printer]
+        when :flat_with_line_numbers
+          RubyProf::FlatPrinterWithLineNumbers
+        else
+          RubyProf.const_get("#{options[:printer].to_s.camelize}Printer")
+      end
+
+      output = if options[:output]
+        options[:output]
+      else
+        case options[:printer]
+          when :call_tree, :call_stack, :graph_html, :dot
+            :file
+          else
+            :log
+        end
+      end
+
+      return yield if output == :log && !ActiveProfiling::LogSubscriber.logger
+
+      RubyProf.measure_mode = RubyProf.const_get(options[:measure_mode].to_s.upcase)
+      GC.disable if options[:disable_gc]
+
+      result = nil
+      profiler_result = RubyProf.profile do
+        result = yield
+      end
+
+      case output
+        when :stdout
+          printer_class.new(profiler_result).print($stdout, options.printer_options)
+        when :log
+          str = StringIO.new
+          printer_class.new(profiler_result).print(str, options.printer_options)
+          str.rewind
+
+          ActiveSupport::Notifications.instrument('profiler_output.active_profiling', {
+            :profiler_output => str.read
+          })
+        when :file
+          path, file_name = if args.first
+            [ File.dirname(args.first), args.first ]
+          elsif options[:file_name]
+            [ File.dirname(options[:file_name]), options[:file_name] ]
+          else
+            time = Time.now.strftime('%Y-%m-%d-%H:%M:%S')
+            hash = Digest::MD5.hexdigest(rand.to_s)[0..6]
+            path = Rails.root.join('log/profiling', self.class.name.underscore)
+            ext = case options[:printer]
+              when :graph_html, :call_stack
+                'html'
+              when :dot
+                'dot'
+              else
+                'log'
+            end
+
+            file_name = [
+              self.action_name,
+              options[:measure_mode],
+              options[:printer],
+              time,
+              hash,
+              ext
+            ].join('.')
+
+            if options[:printer] == :call_tree && !options[:call_tree_prefix].blank?
+              file_name = "#{options[:call_tree_prefix]}#{file_name}"
+            end
+
+            [ path.to_s, path.join(file_name) ]
+          end
+
+          ActiveSupport::Notifications.instrument('profiler_output_to_file.active_profiling', {
+            :file_name => file_name
+          })
+
+          FileUtils.mkdir_p(path)
+          printer_class.new(profiler_result).print(File.open(file_name, 'w'), options[:printer_options])
+      end
+
+      result
+    ensure
+      GC.enable if options[:disable_gc]
+    end
+  end
+
+  self.extend(RubyProfiler)
+end

data/lib/active-profiling/version.rb

@@ -0,0 +1,4 @@
+
+module ActiveProfiling
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: active-profiling
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- J Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: A Rails profiling suite.
+email: dark.panda@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- active-profiling.gemspec
+- lib/active-profiling.rb
+- lib/active-profiling/action_controller/action_profiling.rb
+- lib/active-profiling/gc_statistics.rb
+- lib/active-profiling/log_subscriber.rb
+- lib/active-profiling/railtie.rb
+- lib/active-profiling/ruby_profiler.rb
+- lib/active-profiling/version.rb
+homepage: http://github.com/dark-panda/active-profiling
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: A Rails profiling suite.
+test_files: []