newrelic_rpm 3.3.1 → 3.3.2.beta1

data/CHANGELOG

@@ -1,3 +1,9 @@
+v3.3.2
+  * deployments recipe change: truncate git SHAs to 7 characters
+  * Fixes for obfuscation of PostgreSQL and SQLite queries
+  * Fix for lost database connections when using a forking framework
+  * Workaround for RedHat kernel bug which prevented blocking reads of /proc fs
+  
 v3.3.1
   * improved Ruby 1.8.6 support
   * fix for issues with RAILS_ROOT deprecation warnings

data/lib/new_relic/agent/database.rb

@@ -187,16 +187,36 @@ module NewRelic
         end
         
         def default_sql_obfuscator(sql)
-          sql = sql.dup
-          # This is hardly readable.  Use the unit tests.
-          # remove single quoted strings:
-          sql.gsub!(/'(.*?[^\\'])??'(?!')/, '?')
-          # remove double quoted strings:
-          sql.gsub!(/"(.*?[^\\"])??"(?!")/, '?')
-          # replace all number literals
-          sql.gsub!(/\d+/, "?")
-          sql
+          stmt = sql.kind_of?(Statement) ? sql : Statement.new(sql)
+          adapter = stmt.adapter
+          obfuscated = remove_escaped_quotes(stmt)
+          obfuscated = obfuscate_single_quote_literals(obfuscated)
+          if !(adapter.to_s =~ /postgres/ || adapter.to_s =~ /sqlite/)
+            obfuscated = obfuscate_double_quote_literals(obfuscated)
+          end
+          obfuscated = obfuscate_numeric_literals(obfuscated)
+          obfuscated.to_s # return back to a regular String
+        end
+
+        def remove_escaped_quotes(sql)
+          sql.gsub(/\\"/, '').gsub(/\\'/, '')
         end
+
+        def obfuscate_single_quote_literals(sql)
+          sql.gsub(/'(?:[^']|'')*'/, '?')
+        end
+
+        def obfuscate_double_quote_literals(sql)
+          sql.gsub(/"(?:[^"]|"")*"/, '?')
+        end
+
+        def obfuscate_numeric_literals(sql)
+          sql.gsub(/\b\d+\b/, "?")
+        end
+      end
+
+      class Statement < String        
+        attr_accessor :adapter
       end
     end
   end

data/lib/new_relic/agent/samplers/memory_sampler.rb

@@ -122,18 +122,17 @@ module NewRelic
           # Returns the amount of resident memory this process is using in MB
           #
           def get_memory
-            File.open(proc_status_file, "r") do |f|
-              while !f.eof?
-                if f.readline =~ /RSS:\s*(\d+) kB/i
-                  return $1.to_f / 1024.0
-                end
-              end
+            proc_status = File.open(proc_status_file, "r") {|f| f.read_nonblock(4096).strip }
+            if proc_status =~ /RSS:\s*(\d+) kB/i
+              return $1.to_f / 1024.0
             end
             raise "Unable to find RSS in #{proc_status_file}"
           end
+
           def proc_status_file
             "/proc/#{$$}/status"
           end
+
           def to_s
             "proc status file sampler: #{proc_status_file}"
           end

data/lib/new_relic/agent/transaction_sampler.rb

@@ -1,6 +1,7 @@
 require 'new_relic/agent'
 require 'new_relic/control'
 require 'new_relic/agent/transaction_sample_builder'
+
 module NewRelic
   module Agent
     
@@ -271,8 +272,14 @@ module NewRelic
         return unless builder
         segment = builder.current_segment
         if segment
-          segment[key] = truncate_message(append_new_message(segment[key],
-                                                             message))
+          new_message = truncate_message(append_new_message(segment[key],
+                                                            message))
+          if key == :sql && config.respond_to?(:has_key?) && config.has_key?(:adapter)
+            segment[key] = Database::Statement.new(new_message)
+            segment[key].adapter = config[:adapter]
+          else
+            segment[key] = new_message
+          end
           segment[config_key] = config if config_key
           append_backtrace(segment, duration)
         end
@@ -336,6 +343,7 @@ module NewRelic
         @harvest_count += 1
         if (@harvest_count.to_i % @sampling_rate.to_i) == 0
           result << @random_sample if @random_sample
+          @harvest_count = 0
         end
         nil # don't assume this method returns anything
       end

data/lib/new_relic/control/frameworks/rails3.rb

@@ -10,7 +10,7 @@ module NewRelic
       class Rails3 < NewRelic::Control::Frameworks::Rails
 
         def env
-          ::Rails.env.to_s
+          @env ||= ::Rails.env.to_s
         end
         
         # Rails can return an empty string from this method, causing

data/lib/new_relic/language_support.rb

@@ -27,8 +27,9 @@ module NewRelic::LanguageSupport
     def self.included(base)
       # need to use syck rather than psych when possible
       if defined?(::YAML::ENGINE)
-        unless NewRelic::LanguageSupport.using_engine?('jruby') &&
-                NewRelic::LanguageSupport.using_version?('1.9')
+        if !NewRelic::LanguageSupport.using_engine?('jruby') &&
+            (NewRelic::LanguageSupport.using_version?('1.9.1') ||
+             NewRelic::LanguageSupport.using_version?('1.9.2'))
           base.class_eval do
             def load_newrelic_yml(*args)
               yamler = ::YAML::ENGINE.yamler

data/lib/new_relic/local_environment.rb

@@ -106,7 +106,9 @@ module NewRelic
     def gather_cpu_info
       return unless File.readable? '/proc/cpuinfo'
       @processors = append_environment_value('Processors') do
-        processors = File.readlines('/proc/cpuinfo').select { |line| line =~ /^processor\s*:/ }.size
+        cpuinfo = File.open("/proc/cpuinfo") {|f| f.read_nonblock(4096).strip }
+        processors = cpuinfo.split("\n").select {|line| line =~ /^processor\s*:/ }.size
+        
         raise "Cannot determine the number of processors in /proc/cpuinfo" unless processors > 0
         processors
       end
@@ -156,9 +158,6 @@ module NewRelic
           end
         end
       end
-      append_environment_value 'Database schema version' do
-        ActiveRecord::Migrator.current_version
-      end
     end
     
     # Datamapper version

data/lib/new_relic/rack/browser_monitoring.rb

@@ -15,13 +15,13 @@ module NewRelic::Rack
         # NewRelic::Agent::TransactionInfo.get.force_persist = true
         # NewRelic::Agent::TransactionInfo.get.capture_deep_tt = true
       # end
-      
+
       # if req.params['nr_capture_tt']
         # NewRelic::Agent::TransactionInfo.get.force_persist = true
       # end
-      
+
       result = @app.call(env)   # [status, headers, response]
-      
+
       if (NewRelic::Agent.browser_timing_header != "") && should_instrument?(result[0], result[1])
         response_string = autoinstrument_source(result[2], result[1])
 
@@ -37,24 +37,25 @@ module NewRelic::Rack
     end
 
     def should_instrument?(status, headers)
-      status == 200 && headers["Content-Type"] && headers["Content-Type"].include?("text/html")
+      status == 200 && headers["Content-Type"] && headers["Content-Type"].include?("text/html") &&
+        !headers['Content-Disposition'].to_s.include?('attachment')
     end
 
     def autoinstrument_source(response, headers)
       source = nil
       response.each {|fragment| source ? (source << fragment.to_s) : (source = fragment.to_s)}
       return nil unless source
-      
+
       body_start = source.index("<body")
       body_close = source.rindex("</body>")
 
       if body_start && body_close
         footer = NewRelic::Agent.browser_timing_footer
         header = NewRelic::Agent.browser_timing_header
-                  
+
         if source.include?('X-UA-Compatible')
           # put at end of header if UA-Compatible meta tag found
-          head_pos = source.index("</head>")          
+          head_pos = source.index("</head>")
         elsif head_open = source.index("<head")
           # put at the beginning of the header
           head_pos = source.index(">", head_open) + 1
@@ -71,5 +72,5 @@ module NewRelic::Rack
       source
     end
   end
-  
+
 end

data/lib/new_relic/rack/developer_mode.rb

@@ -83,9 +83,9 @@ module NewRelic
           @obfuscated_sql = @segment.obfuscated_sql
         end
 
-        explanations = @segment.explain_sql
+        headers, explanations = @segment.explain_sql
         if explanations
-          @explanation = explanations.first
+          @explanation = explanations
           if !@explanation.blank?
             first_row = @explanation.first
             # Show the standard headers if it looks like a mysql explain plan

data/lib/new_relic/recipes.rb

@@ -33,10 +33,14 @@ make_notify_task = Proc.new do
           end
           changelog = `#{log_command}`
         end
-        new_revision = rev || source.query_revision(source.head()) do |cmd|
-          logger.debug "executing locally: '#{cmd}'"
-          `#{cmd}`
+        if rev.nil?
+          rev = source.query_revision(source.head()) do |cmd|
+            logger.debug "executing locally: '#{cmd}'"
+            `#{cmd}`
+          end
+          rev = rev[0..6] if scm == :git
         end
+        new_revision = rev
         deploy_options = { :environment => rails_env,
           :revision => new_revision,
           :changelog => changelog,

data/lib/new_relic/stats.rb

@@ -104,43 +104,6 @@ module NewRelic
       stats.merge!(other_stats)
     end
 
-    # split into an array of timeslices whose
-    # time boundaries start on (begin_time + (n * duration)) and whose
-    # end time ends on (begin_time * (n + 1) * duration), except for the
-    # first and last elements, whose begin time and end time are the begin
-    # and end times of this stats instance, respectively.  Yield to caller
-    # for the code that creates the actual stats instance
-    def split(rollup_begin_time, rollup_period)
-      rollup_begin_time = rollup_begin_time.to_f
-      rollup_begin_time += ((self.begin_time - rollup_begin_time) / rollup_period).floor * rollup_period
-
-      current_begin_time = self.begin_time
-      current_end_time = rollup_begin_time + rollup_period
-
-      return [self] if current_end_time >= self.end_time
-
-      timeslices = []
-      while current_end_time < self.end_time do
-        ts = yield(current_begin_time, current_end_time)
-        if ts
-          ts.fraction_of(self)
-          timeslices << ts
-        end
-        current_begin_time = current_end_time
-        current_end_time = current_begin_time + rollup_period
-      end
-
-      if self.end_time > current_begin_time
-        percentage = rollup_period / self.duration + (self.begin_time - rollup_begin_time) / rollup_period
-        ts = yield(current_begin_time, self.end_time)
-        if ts
-          ts.fraction_of(self)
-          timeslices << ts
-        end
-      end
-
-      timeslices
-    end
 
     def is_reset?
       call_count == 0 && total_call_time == 0.0 && total_exclusive_time == 0.0
@@ -216,22 +179,6 @@ module NewRelic
       "[#{Time.at(begin_time.to_f).utc.strftime(format)} UTC, #{'%2.3fs' % duration.to_f}; #{'%2i' % call_count.to_i} calls #{'%4i' % average_call_time.to_f}s]"
     end
 
-    # calculate this set of stats to be a percentage fraction
-    # of the provided stats, which has an overlapping time window.
-    # used as a key part of the split algorithm
-    def fraction_of(s)
-      min_end = (end_time < s.end_time ? end_time : s.end_time)
-      max_begin = (begin_time > s.begin_time ? begin_time : s.begin_time)
-      percentage = (min_end - max_begin) / s.duration
-
-      self.total_exclusive_time = s.total_exclusive_time * percentage
-      self.total_call_time = s.total_call_time * percentage
-      self.min_call_time = s.min_call_time
-      self.max_call_time = s.max_call_time
-      self.call_count = s.call_count * percentage
-      self.sum_of_squares = (s.sum_of_squares || 0) * percentage
-    end
-
     # multiply the total time and rate by the given percentage
     def multiply_by(percentage)
       self.total_call_time = total_call_time * percentage

data/lib/new_relic/transaction_sample.rb

@@ -234,7 +234,7 @@ module NewRelic
               when :raw then v
               when :obfuscated then NewRelic::Agent::Database.obfuscate_sql(v)
               else raise "Invalid value for record_sql: #{options[:record_sql]}"
-            end if options[:record_sql]
+            end.to_s if options[:record_sql]
           when :connection_config
             # don't copy it
           else

data/lib/new_relic/version.rb

@@ -3,8 +3,8 @@ module NewRelic
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 3
-    TINY  = 1
-    BUILD = nil # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    TINY  = 2
+    BUILD = 'beta1' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end
 

data/newrelic_rpm.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{newrelic_rpm}
-  s.version = "3.3.1"
+  s.version = "3.3.2.beta1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Bill Kayser", "Jon Guymon", "Justin George", "Darin Swanson"]
-  s.date = %q{2011-12-15}
+  s.date = %q{2012-01-20}
   s.description = %q{New Relic is a performance management system, developed by New Relic,
 Inc (http://www.newrelic.com).  New Relic provides you with deep
 information about the performance of your web application as it runs

data/test/new_relic/agent/database_test.rb

@@ -83,59 +83,46 @@ class NewRelic::Agent::DatabaseTest < Test::Unit::TestCase
       raise(fake_error)
     end
   end
+  
+  def test_obfuscation_mysql_basic
+    insert = %q[INSERT INTO `X` values("test",0, 1 , 2, 'test')]
+    assert_equal("INSERT INTO `X` values(?,?, ? , ?, ?)",
+                 NewRelic::Agent::Database.obfuscate_sql(insert))
+    select = %q[SELECT `table`.`column` FROM `table` WHERE `table`.`column` = 'value' AND `table`.`other_column` = "other value" LIMIT 1]
+    assert_equal(%q[SELECT `table`.`column` FROM `table` WHERE `table`.`column` = ? AND `table`.`other_column` = ? LIMIT ?],
+                 NewRelic::Agent::Database.obfuscate_sql(select))
+  end
 
-  def test_sql_normalization
-    # basic statement
-    assert_equal "INSERT INTO X values(?,?, ? , ?)",
-    NewRelic::Agent::Database.obfuscate_sql("INSERT INTO X values('test',0, 1 , 2)")
-
-    # escaped literals
-    assert_equal "INSERT INTO X values(?, ?,?, ? , ?)",
-    NewRelic::Agent::Database.obfuscate_sql("INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son')")
-    
-    # multiple string literals
-    assert_equal "INSERT INTO X values(?,?,?, ? , ?)",
-    NewRelic::Agent::Database.obfuscate_sql("INSERT INTO X values('jim''s ssn','x',0, 1 , 2)")
-    
-    # empty string literal
-    # NOTE: the empty string literal resolves to empty string, which for our purposes is acceptable
-    assert_equal "INSERT INTO X values(?,?,?, ? , ?)",
-    NewRelic::Agent::Database.obfuscate_sql("INSERT INTO X values('','x',0, 1 , 2)")
-    
-    # try a select statement
-    assert_equal "select * from table where name=? and ssn=?",
-    NewRelic::Agent::Database.obfuscate_sql("select * from table where name='jim gochee' and ssn=0012211223")
-    
-    # number literals embedded in sql - oh well
-    assert_equal "select * from table_? where name=? and ssn=?",
-    NewRelic::Agent::Database.obfuscate_sql("select * from table_007 where name='jim gochee' and ssn=0012211223")
+  def test_obfuscation_postgresql_basic
+    insert = NewRelic::Agent::Database::Statement.new(%q[INSERT INTO "X" values('test',0, 1 , 2, 'test')])
+    insert.adapter = :postgresql
+    assert_equal('INSERT INTO "X" values(?,?, ? , ?, ?)',
+                 NewRelic::Agent::Database.obfuscate_sql(insert))
+    select = NewRelic::Agent::Database::Statement.new(%q[SELECT "table"."column" FROM "table" WHERE "table"."column" = 'value' AND "table"."other_column" = 'other value' LIMIT 1])
+    select.adapter = :postgresql
+    assert_equal(%q[SELECT "table"."column" FROM "table" WHERE "table"."column" = ? AND "table"."other_column" = ? LIMIT ?],
+                 NewRelic::Agent::Database.obfuscate_sql(select))  
   end
   
-  def test_sql_normalization__single_quotes
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql("INSERT 'this isn''t a real value' into table")
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT '"' into table])
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT ' "some text" \" ' into table])
-    #    could not get this one licked.  no biggie
-    #    assert_equal "INSERT ? into table",
-    #    @agent.send(:default_sql_obfuscator, %q[INSERT '\'' into table])
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT ''' ' into table])
+  def test_obfuscation_escaped_literals
+    insert = %q[INSERT INTO X values('', 'jim''s ssn',0, 1 , 'jim''s son''s son', """jim''s"" hat", "\"jim''s secret\"")]
+    assert_equal("INSERT INTO X values(?, ?,?, ? , ?, ?, ?)",
+                 NewRelic::Agent::Database.obfuscate_sql(insert))
   end
 
-  def test_sql_normalization__double_quotes
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT "this isn't a real value" into table])
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT "'" into table])
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT " \" " into table])
-    assert_equal "INSERT ? into table",
-    NewRelic::Agent::Database.obfuscate_sql(%q[INSERT " 'some text' " into table])
+  def test_obfuscation_mysql_integers_in_identifiers
+    select = %q[SELECT * FROM `table_007` LIMIT 1]
+    assert_equal(%q[SELECT * FROM `table_007` LIMIT ?],
+                 NewRelic::Agent::Database.obfuscate_sql(select))
   end
   
+  def test_obfuscation_postgresql_integers_in_identifiers
+    select = NewRelic::Agent::Database::Statement.new(%q[SELECT * FROM "table_007" LIMIT 1])
+    select.adapter = :postgresql
+    assert_equal(%q[SELECT * FROM "table_007" LIMIT ?],
+                 NewRelic::Agent::Database.obfuscate_sql(select))
+  end
+
   def test_sql_obfuscation_filters
     NewRelic::Agent::Database.set_sql_obfuscator(:replace) do |string|
       "1" + string

data/test/new_relic/rack/browser_monitoring_test.rb

@@ -15,7 +15,7 @@ end
 if middleware_supported?
 class BrowserMonitoringTest < Test::Unit::TestCase
   include Rack::Test::Methods
-  
+
   class TestApp
     def self.doc=(other)
       @@doc = other
@@ -38,11 +38,11 @@ EOL
     end
     include NewRelic::Agent::Instrumentation::Rack
   end
-  
+
   def app
     NewRelic::Rack::BrowserMonitoring.new(TestApp.new)
   end
-  
+
   def setup
     super
     clear_cookies
@@ -54,36 +54,40 @@ EOL
     NewRelic::Agent.instance.stubs(:beacon_configuration).returns(config)
     NewRelic::Agent.stubs(:is_transaction_traced?).returns(true)
   end
-  
+
   def teardown
     super
     clear_cookies
     mocha_teardown
     TestApp.doc = nil
   end
-  
+
   def test_make_sure_header_is_set
     assert NewRelic::Agent.browser_timing_header.size > 0
   end
-  
+
   def test_make_sure_footer_is_set
     assert NewRelic::Agent.browser_timing_footer.size > 0
   end
-  
+
   def test_should_only_instrument_successfull_html_requests
     assert app.should_instrument?(200, {'Content-Type' => 'text/html'})
     assert !app.should_instrument?(500, {'Content-Type' => 'text/html'})
     assert !app.should_instrument?(200, {'Content-Type' => 'text/xhtml'})
   end
 
+  def test_should_not_instrument_when_content_disposition
+    assert !app.should_instrument?(200, {'Content-Type' => 'text/html', 'Content-Disposition' => 'attachment; filename=test.html'})
+  end
+
   def test_insert_timing_header_right_after_open_head_if_no_meta_tags
     get '/'
-    
+
     assert(last_response.body.include?("head>#{NewRelic::Agent.browser_timing_header}"),
            last_response.body)
     TestApp.doc = nil
-  end  
-  
+  end
+
   def test_insert_timing_header_right_before_head_close_if_ua_compatible_found
     TestApp.doc = <<-EOL
 <html>
@@ -98,30 +102,30 @@ EOL
 </html>
 EOL
     get '/'
-    
+
     assert(last_response.body.include?("#{NewRelic::Agent.browser_timing_header}</head>"),
            last_response.body)
   end
-  
+
   def test_insert_timing_footer_right_before_html_body_close
     get '/'
-    
+
     assert_match(/.*NREUMQ\.push.*new Date\(\)\.getTime\(\),"","","","",""\]\)<\/script><\/body>/,
                  last_response.body)
   end
-  
+
   def test_should_not_throw_exception_on_empty_reponse
     TestApp.doc = ''
     get '/'
 
     assert last_response.ok?
   end
-  
+
   def test_token_is_set_in_footer_when_set_by_cookie
     token = '1234567890987654321'
     set_cookie "NRAGENT=tk=#{token}"
     get '/'
-    
+
     assert(last_response.body.include?(token), last_response.body)
   end
 

data/test/new_relic/rack/developer_mode_test.rb

@@ -40,4 +40,35 @@ class DeveloperModeTest < Test::Unit::TestCase
     assert last_response.body.include?('SandwichesController')
     assert last_response.body.include?('index')    
   end  
+
+  def test_explain_sql_displays_query_plan
+    sample = @sampler.samples[0]
+    sql_segment = sample.sql_segments[0]
+    explain_results = NewRelic::Agent::Database.process_resultset(example_explain_as_hashes)
+
+    NewRelic::TransactionSample::Segment.any_instance.expects(:explain_sql).returns(explain_results)
+    get "/newrelic/explain_sql?id=#{sample.sample_id}&segment=#{sql_segment.segment_id}"
+
+    assert last_response.ok?
+    assert last_response.body.include?('PRIMARY')
+    assert last_response.body.include?('Key Length')
+    assert last_response.body.include?('Using index')
+  end
+
+  private
+
+  def example_explain_as_hashes
+    [{
+      'Id' => '1',
+      'Select Type' => 'SIMPLE',
+      'Table' => 'sandwiches',
+      'Type' => 'range',
+      'Possible Keys' => 'PRIMARY',
+      'Key' => 'PRIMARY',
+      'Key Length' => '4',
+      'Ref' => '',
+      'Rows' => '1',
+      'Extra' => 'Using index'
+    }]
+  end
 end

data/test/new_relic/stats_test.rb

@@ -172,21 +172,6 @@ class NewRelic::StatsTest < Test::Unit::TestCase
     assert_equal(s1.time_str(20000), "20.0 s")
   end
 
-  def test_fraction_of
-    s1 = NewRelic::MethodTraceStats.new
-    s2 = NewRelic::MethodTraceStats.new
-    s1.trace_call 10
-    s2.trace_call 20
-    assert_equal(s1.fraction_of(s2).to_s, 'NaN')
-  end
-
-  def test_fraction_of2
-    s1 = NewRelic::MethodTraceStats.new
-    s1.trace_call 10
-    s2 = NewRelic::MethodTraceStats.new
-    assert_equal(s1.fraction_of(s2).to_s, 'NaN')
-  end
-
   def test_multiply_by
     s1 = NewRelic::MethodTraceStats.new
     s1.trace_call 10

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: newrelic_rpm
 version: !ruby/object:Gem::Version 
-  hash: 9
-  prerelease: 
+  hash: 62196449
+  prerelease: 6
   segments: 
   - 3
   - 3
+  - 2
+  - beta
   - 1
-  version: 3.3.1
+  version: 3.3.2.beta1
 platform: ruby
 authors: 
 - Bill Kayser
@@ -18,7 +20,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-15 00:00:00 -08:00
+date: 2012-01-20 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency