rack-insight 0.5.13 → 0.5.14

data/CHANGELOG

@@ -1,5 +1,19 @@
 == HEAD
 
+  * New Features
+
+    * Panel level configurations for :probes are now supported by default on all panels
+    * Auto-magical panel names
+    * Auto-magical table creation (skipped with self.tableless = false in a Panel class definition)
+    * Under construction, or blank, panels have more scaffolding
+    *
+
+== 0.5.13 / 2012-09-10
+
+  * Bug Fixes
+
+    * Fixed the double logging of anything logged with ActiveSupport::BufferedLogger (via the new :panel_configs)
+
   * New Features
 
     * Panel level configuration options for all panels, including extension gems.

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rack-insight (0.5.12)
+    rack-insight (0.5.13)
       rack
       sqlite3 (>= 1.3.3)
       uuidtools (>= 2.1.2)

data/lib/rack/insight/config.rb

@@ -9,7 +9,21 @@ module Rack::Insight
     @verbosity = true
     @rails_log_copy = true
     @filtered_backtrace = true
-    @panel_configs = {}
+    @panel_configs = {
+      :active_record => {:probes => {'ActiveRecord' => [:class, :allocate]}},
+      :active_resource => {:probes => {'ActiveResource::Connection' => [:instance, :request]}},
+      :cache => {:probes => { 'Memcached'     => [:instance, :decrement, :get, :increment, :set,
+                                                                 :add, :replace, :delete, :prepend, :append],
+                              'MemCache'      => [:instance, :decr, :get, :get_multi, :incr, :set, :add, :delete],
+                              'Dalli::Client' => [:instance, :perform] } },
+      :active_record => {:probes => {'ActiveRecord' => [:class, :allocate]}},
+#      :log_panel => The log panel configures its probes in its initializer
+      :sql => {:probes => Hash[%w{ PostgreSQLAdapter MysqlAdapter SQLiteAdapter
+                  Mysql2Adapter OracleEnhancedAdapter }.map do |adapter|
+                    ["ActiveRecord::ConnectionAdapters::#{adapter}", [:instance, :execute]]
+                  end ] },
+      :templates => {:probes => {'ActionView::Template' => [:instance, :render]}}
+    }
 
     DEFAULTS = {
       # You can augment or replace the default set of panel load paths.
@@ -40,7 +54,11 @@ module Rack::Insight
       @log_file = config[:log_file]
       @verbosity = config[:verbosity]
       @filtered_backtrace = config[:filtered_backtrace]
-      @panel_configs = config[:panel_configs]
+
+      config[:panel_configs].each do |panel_name_sym, config|
+        set_panel_config(panel_name_sym, config)
+      end
+
       unless config[:panel_load_paths].kind_of?(Array)
         raise "Rack::Insight::Config.config[:panel_load_paths] is invalid: Expected kind of Array but got #{config[:panel_load_paths].class}"
       end
@@ -49,6 +67,13 @@ module Rack::Insight
       end
     end
 
+    # To preserve :panel_configs settings from extension libraries,
+    # and allowing user config to override the defaults set in this, or other extension gems.
+    def self.set_panel_config(panel_name_sym, config)
+      @panel_configs[panel_name_sym].merge!(config)
+      self.config[:panel_configs][panel_name_sym] = @panel_configs[panel_name_sym]
+    end
+
     def self.logger
       @logger ||= begin
         logga = self.config[:logger]

data/lib/rack/insight/database.rb

@@ -4,15 +4,26 @@ require 'base64'
 
 module Rack::Insight
   class Database
+
+    # Classes including this module must define the following structure:
+    #    class FooBar
+    #      include Rack::Insight::Database
+    #      class << self
+    #        attr_accessor :has_table
+    #      end
+    #      # Setting as below is only required when not using a table (Why are you including this module then?)
+    #      # self.has_table = false
+    #    end
     module RequestDataClient
       def key_sql_template(sql)
         @key_sql_template = sql
       end
 
       def table_setup(name, *keys)
+        self.class.has_table = true
         @table = DataTable.new(name, *keys)
         if keys.empty?
-          @key_sql_template = ""
+          @key_sql_template = ''
         end
       end
 

data/lib/rack/insight/instrumentation/client.rb

@@ -2,6 +2,7 @@ require 'rack/insight/instrumentation/package-definition'
 module Rack::Insight::Instrumentation
   module Client
     def probe(collector, &block)
+      self.class.is_probed = true
       ::Rack::Insight::Instrumentation::PackageDefinition::probe(collector, &block)
     end
 

data/lib/rack/insight/panel.rb

@@ -20,7 +20,11 @@ module Rack::Insight
 
       include Rack::Insight::Logging
 
-      attr_accessor :template_root
+      attr_accessor :template_root, :is_probed, :has_table, :is_magic
+      @is_probed = false  # Once a panel is probed this should be set to true
+      @has_table = true   # default to true.  Panels without tables override with self.has_table = false
+      @is_magic = false   # check this to wrap any functionality targeted at magic panels.
+
       def file_index
         return @file_index ||= Hash.new do |h,k|
           h[k] = []
@@ -33,10 +37,17 @@ module Rack::Insight
 
       def from_file(rel_path)
         old_rel, Thread::current['rack-panel_file'] = Thread::current['rack-panel_file'], rel_path
-        Rack::Insight::Config.config[:panel_load_paths].each do |load_path|
+        load_paths_to_check = Rack::Insight::Config.config[:panel_load_paths].length
+        Rack::Insight::Config.config[:panel_load_paths].each_with_index do |load_path, index|
           begin
             require File::join(load_path, rel_path)
+            break # once found
           rescue LoadError => e
+            # TODO: If probes are defined for this panel, instantiate a magic panel
+            # if self.has_custom_probes?
+            if (index + 1) == load_paths_to_check # You have failed me for the last time!
+              warn "Rack::Insight #{e.class}: Unable to find panel specified as '#{rel_path}'.  Looked in the following :panel_load_paths: #{Rack::Insight::Config.config[:panel_load_paths].inspect}."
+            end
           end
         end
         return (file_index[rel_path] - panel_exclusion)
@@ -91,6 +102,48 @@ module Rack::Insight
       else
         @app = app
       end
+
+      # User has explicitly declared what classes/methods to probe:
+      #   Rack::Insight::Config.configure do |config|
+      #     config[:panel_configs][:log] = {:probes => {'Logger' => [:instance, :add] } }
+      #     # OR EQUIVALENTLY
+      #     config[:panel_configs][:log] = {:probes => ['Logger', :instance, :add] }
+      #   end
+      panel_name = self.underscored_name.to_sym
+      if self.has_custom_probes?(panel_name)
+        custom_probes = Rack::Insight::Config.config[:panel_configs][panel_name][:probes]
+        if custom_probes.kind_of?(Hash)
+          probe(self) do
+            custom_probes.each do |klass, method_probes|
+              probe_type = method_probes.shift
+              instrument klass do
+                self.send("#{probe_type}_probe", *method_probes)
+              end
+            end
+          end
+        elsif custom_probes.kind_of?(Array) && custom_probes.length >=3
+          probe(self) do
+            custom_probes.each do |probe|
+              klass = probe.shift
+              probe_type = probe.shift
+              instrument klass do
+                self.send("#{probe_type}_probe", *probe)
+              end
+            end
+          end
+        else
+          raise "Expected Rack::Insight::Config.config[:panel_configs][#{self.as_sym.inspect}][:probes] to be a kind of Hash or an Array with length >= 3, but is a #{Rack::Insight::Config.config[:panel_configs][self.as_sym][:probes].class}"
+        end
+      end
+
+      # Setup a table for the panel unless
+      # 1. self.has_table = false has been set for the Panel class
+      # 2. class instance variable @has_table has been set to false
+      # 3. table_setup has already been called by the sub class' initializer
+      if !has_table?
+        table_setup(self.name)
+      end
+      #puts "Initalization Complete for #{panel_name}\n1. #{self.is_magic?} && 2. #{self.has_table?} && 3. #{self.is_probed?} 4. #{self.has_custom_probes?}"
     end
 
     def call(env)
@@ -113,20 +166,126 @@ module Rack::Insight
       {}
     end
 
+    def has_table?
+      !!self.class.has_table
+    end
+
+    def is_magic?
+      !!self.class.is_magic
+    end
+
     def has_content?
       true
     end
 
+    def is_probed?
+      !!self.class.is_probed
+    end
+
+    def has_custom_probes?(panel_name = self.underscored_name.to_sym)
+      #puts "Rack::Insight::Config.config[:panel_configs][#{panel_name.inspect}]: #{Rack::Insight::Config.config[:panel_configs][panel_name].inspect}"
+      Rack::Insight::Config.config[:panel_configs][panel_name].respond_to?(:[]) &&
+        !Rack::Insight::Config.config[:panel_configs][panel_name][:probes].nil?
+    end
+
+    # The name informs the table name, and the panel_configs hash among other things.
+    # Override in subclass panels if you want a custom name
     def name
-      "Unnamed panel: #{self.class.name}" #for shame
+      self.underscored_name
+    end
+
+    # Mostly stolen from Rails' ActiveSupport' underscore method:
+    # See activesupport/lib/active_support/inflector/methods.rb, line 77
+    # HTTPClientPanel => http_client
+    # LogPanel => log
+    # ActiveRecordPanel => active_record
+    def underscored_name(word = self.class.to_s)
+      @underscored_name ||= begin
+        words = word.dup.split('::')
+        word = words.last
+        if word == 'Panel'
+          word = words[-2] # Panel class is Panel... and this won't do.
+        end
+        #word.gsub!(/(?:([A-Za-z\d])|^)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+        word.gsub!(/Panel$/,'')
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+    end
+
+    def camelized_name(str = self.underscored_name)
+      str.split('_').map {|w| w.capitalize}.join
     end
 
     def heading_for_request(number)
-      heading rescue "xxx" #XXX: no panel should need this
+      if !self.has_table?
+        heading
+      else
+        num = count(number)
+        if num == 0
+          heading
+        else
+          "#{self.camelized_name} (#{num})"
+        end
+      end
+      rescue 'XXX' # no panel should need this
     end
 
     def content_for_request(number)
-      content rescue "" #XXX: no panel should need this
+      logger.info("Rack::Insight is using default content_for_request for #{self.class}") if verbose(:med)
+      if !self.has_table?
+        logger.info("#{self.class} is being used without a table") if verbose(:med)
+        content
+      elsif self.is_probed?
+        html = "<h3>#{self.camelized_name}</h3>"
+        invocations = retrieve(number)
+        if invocations.length > 0 && invocations.first.is_a?(Rack::Insight::Panel::DefaultInvocation)
+          html += '<table><thead><tr>'
+          logger.info("Rack::Insight is using magic content for #{self.class}, which is probed") if verbose(:med)
+          members = invocations.first.members # is a struct, so we have members, not keys
+          members.each do |member|
+            html += '<td>' << member.to_s << '</td>'
+          end
+          html += '</tr></thead><tbody>'
+          invocations.each do |invocation|
+            html += '<tr>'
+            members.each do |member|
+              html += '<td>' << invocation.send(member).inspect << '</td>'
+            end
+            html += '</tr>'
+          end
+          html += '</tbody></table>'
+        else
+          html += '<p>No Data Available</p>'
+        end
+        html
+      else
+        content
+      end
+    rescue 'XXX' #XXX: no panel should need this
+    end
+
+    def heading
+      self.camelized_name
+    end
+
+    def content
+      logger.info("Rack::Insight is using default content for #{self.class}") if verbose(:med)
+      html = "<h3>#{self.camelized_name}</h3>"
+      html += '<p>Add a content method to your panel</p>'
+      html
+    end
+
+    # Override in subclasses.
+    # This is to make magic classes work.
+    def after_detect(method_call, timing, args, result)
+      #puts "Default After Detect for #{self.underscored_name}: 1. #{self.is_magic?} && 2. #{self.has_table?} && 3. #{self.is_probed?}"
+      if self.is_magic? && self.has_table? && self.is_probed?
+        store(@env, DefaultInvocation.new(method_call.to_s, timing.duration, args, result))
+      end
     end
 
     def before(env)
@@ -138,6 +297,16 @@ module Rack::Insight
     def render(template)
     end
 
+    # For Magic Panels (not fully implemented)
+    class DefaultInvocation < Struct.new :method, :time, :args, :result
+      def initialize(*args)
+        @time = human_time(args[1])
+      end
+      def human_time(t)
+        "%.2fms" % (t * 1_000)
+      end
+    end
+
   end
 
 end

data/lib/rack/insight/panels/active_record_panel.rb

@@ -1,16 +1,5 @@
 module Rack::Insight
   class ActiveRecordPanel < Panel
-    def initialize(app)
-      super
-
-      table_setup("active_record")
-
-      probe(self) do
-        instrument "ActiveRecord::Base" do
-          class_probe :allocate
-        end
-      end
-    end
 
     def request_start(env, start)
       @records = Hash.new{ 0 }
@@ -24,10 +13,6 @@ module Rack::Insight
       store(env, @records)
     end
 
-    def name
-      "active_record"
-    end
-
     def heading_for_request(number)
       record = retrieve(number).first
       total = record.inject(0) do |memo, (key, value)|

data/lib/rack/insight/panels/active_resource_panel.rb

@@ -6,16 +6,6 @@ module Rack::Insight
     #require "rack/insight/panels/sql_panel/panel_app"
     #require "rack/insight/panels/sql_panel/query"
 
-    def initialize(app)
-      super
-      probe(self) do
-        instrument "ActiveResource::Connection" do
-          instance_probe :request
-        end
-      end
-      table_setup("active_resource_requests")
-    end
-
     def after_detect(method_call, timing, arguments, results)
       body = "<no body>"
       if results.respond_to? :body
@@ -30,10 +20,6 @@ module Rack::Insight
       end)
     end
 
-    def name
-      "active_resource"
-    end
-
     def heading_for_request(number)
       queries = retrieve(number)
       "ARes: #{queries.size} Queries (%.2fms)" % total_time(queries)

data/lib/rack/insight/panels/cache_panel.rb

@@ -4,27 +4,6 @@ module Rack::Insight
     require "rack/insight/panels/cache_panel/panel_app"
     require "rack/insight/panels/cache_panel/stats"
 
-    def initialize(app)
-      super
-
-      probe(self) do
-        instrument("Memcached") do
-          instance_probe :decrement, :get, :increment, :set, :add,
-            :replace, :delete, :prepend, :append
-        end
-
-        instrument("MemCache") do
-          instance_probe :decr, :get, :get_multi, :incr, :set, :add, :delete
-        end
-
-        instrument("Dalli::Client") do
-          instance_probe :perform
-        end
-      end
-
-      table_setup("cache")
-    end
-
     def request_start(env, start)
       @stats = Stats.new
     end
@@ -46,10 +25,6 @@ module Rack::Insight
       PanelApp.new
     end
 
-    def name
-      "cache"
-    end
-
     def heading_for_request(number)
       stats = retrieve(number).first
 

data/lib/rack/insight/panels/log_panel.rb

@@ -22,8 +22,12 @@ module Rack::Insight
     end
 
     def initialize(app)
-      probe(self) do
-        if !Rack::Insight::Config.config[:panel_configs][:log_panel].respond_to?(:[])
+
+      # Call super before setting up probes in case there are any custom probes configured
+      super # will setup custom probes
+
+      unless is_probed?
+        probe(self) do
           # Trying to be smart...
           if defined?(ActiveSupport)
             instrument "ActiveSupport::BufferedLogger" do
@@ -34,31 +38,8 @@ module Rack::Insight
               instance_probe :add
             end
           end
-        else
-          # User has explicitly declared what log classes to monitor:
-          #   Rack::Insight::Config.configure do |config|
-          #     config[:panel_configs][:log_panel] = {:watch => {'Logger' => :add}}
-          #   end
-          Rack::Insight::Config.config[:panel_configs][:log_panel][:watch].each do |klass, method_probe|
-            instrument klass do
-              instance_probe method_probe
-            end
-          end
         end
       end
-
-      table_setup("log_entries")
-
-      super
-    end
-
-    def name
-      "log"
-    end
-
-    def heading_for_request(number)
-      num = count(number)
-      "Logs (#{num})"
     end
 
     def content_for_request(number)

data/lib/rack/insight/panels/memory_panel.rb

@@ -1,10 +1,6 @@
 module Rack::Insight
 
   class MemoryPanel < Panel
-    def initialize(app)
-      super
-      table_setup("memory_records")
-    end
 
     def before(env)
       @original_memory = `ps -o rss= -p #{$$}`.to_i
@@ -27,10 +23,6 @@ module Rack::Insight
       false
     end
 
-    def name
-      "Memory"
-    end
-
   end
 
 end

data/lib/rack/insight/panels/mongo_panel.rb

@@ -4,6 +4,8 @@ module Rack::Insight
     require "rack/insight/panels/mongo_panel/mongo_extension"
     require "rack/insight/panels/mongo_panel/stats"
 
+    self.has_table = false
+
     def self.record(command, &block)
       return block.call unless Rack::Insight.enabled?
 
@@ -22,10 +24,6 @@ module Rack::Insight
       Thread.current["rack-insight.mongo"] ||= Stats.new
     end
 
-    def name
-      "mongo"
-    end
-
     def heading
       "Mongo: %.2fms (#{self.class.stats.queries.size} calls)" % self.class.stats.time
     end

data/lib/rack/insight/panels/rails_info_panel.rb

@@ -1,9 +1,7 @@
 module Rack::Insight
   class RailsInfoPanel < Panel
 
-    def name
-      "rails_info"
-    end
+    self.has_table = false
 
     def heading
       return unless (defined?(Rails) && defined?(Rails::Info))

data/lib/rack/insight/panels/redis_panel.rb

@@ -5,6 +5,8 @@ module Rack::Insight
 
     require "rack/insight/panels/redis_panel/stats"
 
+    self.has_table = false
+
     def self.record(redis_command_args, backtrace, &block)
       return block.call unless Rack::Insight.enabled?
 
@@ -23,10 +25,6 @@ module Rack::Insight
       Thread.current["rack-insight.redis"] ||= Stats.new
     end
 
-    def name
-      "redis"
-    end
-
     def heading
       "Redis: %.2fms (#{self.class.stats.queries.size} calls)" % self.class.stats.time
     end

data/lib/rack/insight/panels/request_variables_panel.rb

@@ -1,14 +1,5 @@
 module Rack::Insight
   class RequestVariablesPanel < Panel
-    def initialize(app)
-      super
-
-      table_setup("request_variables")
-    end
-
-    def name
-      "request_variables"
-    end
 
     def after(env,status,headers,body)
       sections = {}

data/lib/rack/insight/panels/speedtracer_panel.rb

@@ -52,12 +52,10 @@ module Rack::Insight
       super
     end
 
-
     def call(env)
       env['rack-insight.speedtracer-id'] = @uuid
 
       status, headers, body = @app.call(env)
-
       store(env, env['rack-insight.speedtracer-id'], env['rack-insight.speedtracer-record'])
       headers['X-TraceUrl'] = '__insight__/speedtracer?id=' + env['rack-insight.speedtracer-id']
       return [status, headers, body]
@@ -67,10 +65,6 @@ module Rack::Insight
       { "speedtracer" => TraceApp.new }
     end
 
-    def name
-      "speedtracer"
-    end
-
     def heading
       "#{table_length} traces"
     end

data/lib/rack/insight/panels/speedtracer_panel/trace-app.rb

@@ -7,6 +7,11 @@ module Rack::Insight
 
       FourOhFour = [404, {"Content-Type" => "text/html"}, "App tracker doesn't know that path or id"].freeze
 
+      class << self
+        attr_accessor :has_table
+      end
+      self.has_table = true
+
       def initialize
         table_setup("speedtracer", "uuid")
         key_sql_template = "'%s'"

data/lib/rack/insight/panels/sphinx_panel.rb

@@ -4,6 +4,8 @@ module Rack::Insight
     require "rack/insight/panels/sphinx_panel/sphinx_extension"
     require "rack/insight/panels/sphinx_panel/stats"
 
+    self.has_table = false
+
     def self.record(*sphinx_command_args, &block)
       return block.call unless Rack::Insight.enabled?
 
@@ -22,10 +24,6 @@ module Rack::Insight
       Thread.current["rack-insight.sphinx"] ||= Stats.new
     end
 
-    def name
-      "sphinx"
-    end
-
     def heading
       "Sphinx: %.2fms (#{self.class.stats.queries.size} calls)" % self.class.stats.time
     end

data/lib/rack/insight/panels/sql_panel.rb

@@ -7,19 +7,6 @@ module Rack::Insight
     require "rack/insight/panels/sql_panel/panel_app"
     require "rack/insight/panels/sql_panel/query"
 
-    def initialize(app)
-      super
-      probe(self) do
-        %w{ PostgreSQLAdapter MysqlAdapter SQLiteAdapter
-            Mysql2Adapter OracleEnhancedAdapter }.each do |adapter|
-          instrument "ActiveRecord::ConnectionAdapters::#{adapter}" do
-            instance_probe :execute
-          end
-        end
-      end
-      table_setup("sql_queries")
-    end
-
     def self.panel_mappings
       { "sql" => PanelApp.new }
     end
@@ -34,10 +21,6 @@ module Rack::Insight
       end)
     end
 
-    def name
-      "sql"
-    end
-
     def heading_for_request(number)
       queries = retrieve(number)
       "#{queries.size} Queries (%.2fms)" % total_time(queries)

data/lib/rack/insight/panels/templates_panel.rb

@@ -6,14 +6,6 @@ module Rack::Insight
     def initialize(app)
       super
 
-      probe(self) do
-        instrument "ActionView::Template" do
-          instance_probe :render
-        end
-      end
-
-      table_setup("templates")
-
       @current = nil
     end
 
@@ -40,17 +32,12 @@ module Rack::Insight
       @current = @current.parent
     end
 
-    def name
-      "templates"
-    end
-
     def heading_for_request(number)
       "Templates: %.2fms" % (retrieve(number).inject(0.0){|memo, rendering| memo + rendering.duration})
     end
 
     def content_for_request(number)
-      result = render_template "panels/templates", :root_rendering => retrieve(number).first
-      return result
+      render_template "panels/templates", :root_rendering => retrieve(number).first
     end
 
   end

data/lib/rack/insight/panels/timer_panel.rb

@@ -2,14 +2,6 @@ require 'benchmark'
 
 module Rack::Insight
   class TimerPanel < Panel
-    def initialize(app)
-      super
-      table_setup("timer")
-    end
-
-    def name
-      "timer"
-    end
 
     def call(env)
       status, headers, body = nil
@@ -36,5 +28,6 @@ module Rack::Insight
     def content_for_request(number)
       render_template "panels/timer", :measurements => retrieve(number).first
     end
+
   end
 end

data/lib/rack/insight/public/__insight__/insight.js

@@ -9,6 +9,7 @@ jQuery(function($) {
 
     Insight.prototype = {
       switchCurrentPanel: function() {
+        console.log(this.panel_id);
         if(this.request_id && this.panel_id) {
           this.current = $('#rack-insight #request_' + this.request_id + ' #' + this.panel_id)
         }

data/lib/rack/insight/version.rb

@@ -1,7 +1,7 @@
 module Rack
   module Insight
 
-  VERSION = '0.5.13'
+  VERSION = '0.5.14'
 
   end
 end

data/lib/rack/insight/views/headers_fragment.html.erb

@@ -4,7 +4,7 @@
   <li>
   <% begin %>
     <% if panel.has_content? %>
-      <a href="#" class="<%= panel.name %>">
+      <a href="#" class="<%= panel.camelized_name %>Panel">
         <%= panel.heading_for_request(request_id) %>
       </a>
     <% else %>

data/lib/rack/insight/views/request_fragment.html.erb

@@ -1,7 +1,7 @@
 <div id="request_<%=request_id%>">
   <% panels.each do |panel| %>
     <% if panel.has_content? %>
-      <div class="panel_content" id="<%= panel.name %>">
+      <div class="panel_content" id="<%= panel.camelized_name %>Panel">
         <div class="panel_controls">
           <form action="#">
             <select id="request_id_menu" name="current_request">

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rack-insight
 version: !ruby/object:Gem::Version
-  version: 0.5.13
+  version: 0.5.14
   prerelease: 
 platform: ruby
 authors:
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-10 00:00:00.000000000 Z
+date: 2012-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack