imprint 1.3.0 → 1.4.0

data/Gemfile

@@ -1,5 +1,4 @@
 source 'https://rubygems.org'
-source "http://geminabox.lsqa.net"
 
 # Specify your gem's dependencies in imprint.gemspec
 gemspec

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Dan Mayer
+Copyright (c) 2014 LivingSocial, Inc.
 
 MIT License
 

data/README.md

@@ -1,12 +1,21 @@
 # Imprint
 
-Imprint helps track requests across multiple log lines or applications. It consists of a lightweight class and middleware to help set tracing ids.
+Imprint helps track requests across multiple log lines or applications. It
+consists of a lightweight class and middleware to help set tracing ids.
 
-It also has a file which can be used to bootstrap default rails logging to embedding the imprint `trace_id` on each line logged.
+It also has a file which can be used to bootstrap default rails logging to
+embedding the imprint `trace_id` on each line logged.
 
-Supporting tracing between applications requires updating client calls between applications, at the moment we don't try to monkey patch any of that in and expect responsible clients to add the header manually as described in the Usage section below.
+Supporting tracing between applications requires updating client calls between
+applications, at the moment we don't try to monkey patch any of that in and
+expect responsible clients to add the header manually as described in the Usage
+section below.
 
-If you have seen [ActionDispatch::RequestId](http://api.rubyonrails.org/classes/ActionDispatch/RequestId.html). Imprint is basically a generic Rack version of that idea. It works with Rails 3, Sinatra, and Pure Rack. Beyond that it also provides some helpers and configuration around the trace_id usage.
+If you have seen
+[ActionDispatch::RequestId](http://api.rubyonrails.org/classes/ActionDispatch/RequestId.html).
+Imprint is basically a generic Rack version of that idea. It works with Rails 3,
+Sinatra, and Pure Rack. Beyond that it also provides some helpers and
+configuration around the trace_id usage.
 
 ## Installation
 
@@ -56,10 +65,7 @@ def log(message = nil, severity = :info)
   log_raw(message, severity) do
     message = yield if block_given?
     # append imprint trace
-    if (defined?(Imprint::Tracer.get_trace_id)) && message && message.is_a?(String) && message.length > 1 && Imprint::Tracer.get_trace_id.get_trace_id
-      message = "#{message}\n" unless message[-1] == "\n"
-      message = message.gsub("\n"," [trace_id=#{Imprint::Middleware.get_trace_id}]\n")
-    end
+	Imprint::Tracer.insert_trace_id_in_message(message) if defined?(Imprint::Tracer)
     format = []
     format << Time.now.to_f
     format << @host
@@ -72,9 +78,27 @@ def log(message = nil, severity = :info)
 end
 ```
 
+## Params logging options
+
+By default imprint will only log the query_params opposed to all params. This is because some of our apps don't filter logs well enough. If you are filtering correctly you might want more of the parameters logged. All params are still filtered by the `Rails.application.config.filter_parameters`.
+
+There are three options:
+
+* `FULL_PARAMS` log all params
+* `QUERY_PARAMS` log query params only (default)
+* `FULL_GET_PARAMS` log full params on get requests and query only on post requests
+
+To change from the default send the config option `:param_level` to `Imprint.configure`. You most likely want to do this in your `environment.rb`
+
+    Imprint.configure({
+                   :param_level => Imprint::FULL_GET_PARAMS
+                 })
+
+
+
 ## Optional Helpers
 
-You can get a configurable log entrypoint for apps that allows for some intial logging on each request. This is intended to work well and be combined with lograge, but can be helpful on its own. To use the helpers follow the steps below.
+You can get a configurable log entrypoint for apps that allows for some initial logging on each request. This is intended to work well and be combined with lograge, but can be helpful on its own. To use the helpers follow the steps below.
 
 edit `config/application.rb` and append the lines below, with whatever options make sense for your projects:
 
@@ -163,6 +187,119 @@ def self.http_get(url)
   end
 end
 ```
+## Why, and How
+
+Large systems that are composed of multiple communicating, cooperating parts can
+be difficult to understand.  The idea of Imprint is that it is very useful to
+assign a unique identifier to each *top-level*, *initiating* event that starts a
+series of operations within your system, and have that identifier propagated
+throughout the entire system, and attached to relevant diagnostic information
+(especially log messages).  If a system is consistent about doing this, it
+becomes easy to trace or visualize *all* of the actions that are taken as a part
+of processing some request or event, or as side effects.  That can be extremely
+useful for diagnosing bugs, finding bottlenecks, documenting intrusions, or
+simply understanding the structure of a large complex system.
+
+Imprint calls these identifiers *trace ids*.
+
+Initiating events are, technically, anything that takes place in your system
+that does not already have a trace id associated with it.  Typically, they
+include:
+
+* Initial browser requests from users (internal or external) using web
+  applications
+* Cron jobs or other scheduled jobs that initiate periodic processing
+* API requests that come from integration partners
+
+Imprint and tools like it should log all initiating events; that is, they
+should log each time that they assign a new trace id to a request or event
+that does not already have one.  If you see initiating events where you do not
+expect them, that might just mean that part of your system is not propagating
+existing trace ids properly as it sends messages or calls other services.
+However, it might indicate an attempt to penetrate your system in an
+unauthorized way.  It is a good idea to catalog the known initiating events in
+your system, and set up some kind of monitoring to notice and alert you of
+unexpected ones.
+
+Request tracing across a complex system can't be accomplished just by a single
+Ruby gem.  It requires cooperation from all of the applications, services,  and
+components of the system.  The rest of this section documents how Imprint works
+and what it expects from the other parts of the system, to help you implement
+request tracing across all of the parts of your system, even if they are not
+Rails applications or even written in Ruby.
+
+### What Imprint Does
+
+Here's what Imprint actually does. You should implement similar functionality
+for parts of your system that are not written in Ruby, or are not Rails
+applications.
+
+1. Imprint patches the Rails logger so that *all* log messages incorporate the
+   trace id if one is in effect when the message is logged.  Each line of the
+   log messages ends like this: "&nbsp;trace_id=1411414337_pDLsqp".
+2. Immediately upon receipt of each new request, Imprint checks to see whether
+   the request came with an attached trace id, by checking for the presence
+   of an `::Imprint::Tracer::TRACER_HEADER` ("HTTP_TRACE_ID") HTTP header. If
+   present, that trace id is kept as the trace id of the current request.
+3. If no trace id was included with the request, a new trace id is assigned.
+   The new trace id consists of an integer timestamp (the number of seconds
+   since the Unix epoch) plus a random string of six upper- and lowercase
+   ASCII letters, separated by an underscore (e.g., "1411414337_pDLsqp").
+   Then it logs an initiating event
+   ("trace_status=initiated&nbsp;trace_id=1411414337_pDLsqp").
+4. Once a trace id has been found or generated, it is placed where every part
+   of the application that participates in the current request has access to
+   it (a variable scoped to the current thread, accessed via
+   `::Imprint::Tracer::get_trace_id`).
+
+### What Cooperating Applications and Components Should Do
+
+Imprint is just part of the total solution; applications and services have
+responsibilities as well.
+
+1. Either use Imprint (if you're building a Rails app) or implement equivalent
+   functionality in your app.
+2. Any HTTP requests, Resque jobs, Kafka messages, or anything else that
+   involves a different application or service in processing the request
+   should be passed the trace id, either in the HTTP header or in an envelope
+   field or something similar with the name `::Imprint::Tracer::TRACER_KEY`
+   ("trace_id").  (See "Threading Considerations" below if your app employs
+   concurrency in request processing.)
+
+### Threading Considerations
+
+In request tracing, it's crucial that the trace id is associated with
+*everything* that is done because of the initiating event.  This means that
+every part of an application or component must have access to the current trace
+id, even if they are in different threads or processes than the one that
+initially recorded the trace id.
+
+The Rails architecture makes this easy. From the time a Rails app receives a
+request, all of the processing for that request takes place in a single thread.
+So Imprint puts the trace id in a variable scoped to the current thread.
+
+However, many applications or frameworks employ concurrency during the
+processing of a single request.  Such systems need to ensure that the other
+threads (or processes, perhaps) that participate also know the trace id of
+what they're working on.
+
+If the initial thread simply spawns new threads to do part of the work, it
+might work to simply use something like Java's `InheritableThreadLocal`.
+
+More typically, though, parts of the work will be farmed out to worker threads
+(actors, for example) that already exist in a pool and handle work for many
+requests during their lifetime. In such cases, the messages or task
+descriptions that are sent to those workers should include the trace id
+associated with that work, and the workers should ensure that the appropriate
+trace id is included in all of their processes.
+
+So, in short: each such worker thread should be treated as if it were a
+separate service: it should receive a trace id with each work request, attach
+that trace id to all log messages that are part of that work request, and
+propagate it in any other service or work requests that it sends. The exception
+is that it should be considered an error if those internal worker threads
+receive a request without a trace id; it's not reasonable for that to be an
+initiating event.
 
 ## Notes / TODO
 

data/Rakefile

@@ -7,12 +7,3 @@ Rake::TestTask.new(:test) do |test|
   test.pattern = 'test/**/*_test.rb'
   test.verbose = true
 end
-
-
-# bundle exec rake console
-# LS::BrowseService.host = 'http://browse-service.browse-service.qa.livingsocial.net/'
-# LS::BrowseService::Client.new.get_category('washington-d-c','food-deals')
-desc "start a console with the gem loaded"
-task :console do
-  sh "irb -rubygems -I lib -r ls/browse-service-client.rb"
-end

data/imprint.gemspec

@@ -20,7 +20,6 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "mocha", "~> 0.14.0"
   spec.add_development_dependency "shoulda"
   spec.add_development_dependency "rack"
   spec.add_development_dependency "simplecov"

data/lib/imprint/log_helpers.rb

@@ -22,6 +22,7 @@ module Imprint
       end
 
       data_append << " params: "
+
       if param_level==Imprint::FULL_PARAMS
         set_full_params(log_filter, data_append)
       elsif param_level==Imprint::FULL_GET_PARAMS
@@ -34,14 +35,17 @@ module Imprint
         set_query_params(log_filter, data_append)
       end
 
-      cookies_whitelist.each do |cookie_key|
-                         cookie_val = cookies[cookie_key] ? cookies[cookie_key] : 'nil'
-                         data_append << " #{cookie_key}=\"#{cookie_val}\""
-                       end
+      if defined? cookies
+        cookies_whitelist.each do |cookie_key|
+          cookie_val = cookies[cookie_key] ? cookies[cookie_key] : 'nil'
+          data_append << " #{cookie_key}=\"#{cookie_val}\""
+        end
+      end
 
       logger.info "Started request_method=#{request.method.inspect} request_url=\"#{request.path}\" request_time=\"#{Time.now.to_default_s}\" request_ip=#{request.remote_ip.inspect} #{data_append}"
-    rescue
-      logger.error "error logging log_entrypoint for request"
+    rescue => e
+      logger.error "error logging log_entrypoint for request: #{e.inspect}"
+      logger.error e.backtrace.take(10).join("\n")
     end
 
     def set_full_params(log_filter, data_append)

data/lib/imprint/middleware.rb

@@ -1,16 +1,34 @@
+require 'logger'
+
 module Imprint
   class Middleware
-    
+
     def self.set_request_trace_id(rack_env)
-      existing_id = rack_env[Imprint::Tracer::TRACER_HEADER] || rack_env[Imprint::Tracer::RAILS_REQUEST_ID]
-      existing_id ||= "#{Time.now.to_i}_#{Imprint::Tracer.rand_trace_id}"
-      Imprint::Tracer.set_trace_id(existing_id, rack_env)
+      trace_id = rack_env[Imprint::Tracer::TRACER_HEADER] || rack_env[Imprint::Tracer::RAILS_REQUEST_ID]
+      if trace_id.nil?
+        trace_id = "#{Time.now.to_i}_#{Imprint::Tracer.rand_trace_id}"
+        logger.info("trace_status=initiated trace_id=#{trace_id}")
+      end
+      Imprint::Tracer.set_trace_id(trace_id, rack_env)
+      trace_id
+    end
+
+    def self.logger=(logger)
+      @logger = logger
     end
-    
+
+    def self.logger
+      @logger ||= if defined?(Rails.logger)
+                    Rails.logger
+                  else
+                    Logger.new(STDOUT)
+                  end
+    end
+
     def initialize(app, opts = {})
       @app = app
     end
-    
+
     def call(env)
       ::Imprint::Middleware.set_request_trace_id(env)
       @app.call(env)

data/lib/imprint/rails_logger.rb

@@ -10,21 +10,21 @@ if defined?(ActiveSupport::BufferedLogger)
           # If a newline is necessary then create a new message ending with a newline.
           # Ensures that the original message is not mutated.
           message = "#{message}\n" unless message[-1] == "\n"
-          if (defined?(Imprint::Tracer)) && message && message.is_a?(String) && message.length > 1 && Imprint::Tracer.get_trace_id && !message.include?('trace_id=')
-            message = message.gsub("\n"," trace_id=#{Imprint::Tracer.get_trace_id}\n")
+          if defined?(Imprint::Tracer)
+            Imprint::Tracer.insert_trace_id_in_message(message)
           end
           buffer << message
           auto_flush
           message
         else
-          # rails 3.2.x 
+          # rails 3.2.x
           return if !level.nil? && (level > severity)
           message = (message || (block && block.call) || progname).to_s
           # If a newline is necessary then create a new message ending with a newline.
           # Ensures that the original message is not mutated.
           message = "#{message}\n" unless message[-1] == "\n"
-          if (defined?(Imprint::Tracer)) && message && message.is_a?(String) && message.length > 1 && Imprint::Tracer.get_trace_id && !message.include?('trace_id=')
-            message = message.gsub("\n"," trace_id=#{Imprint::Tracer.get_trace_id}\n")
+          if defined?(Imprint::Tracer)
+            Imprint::Tracer.insert_trace_id_in_message(message)
           end
           @log.add(severity, message, progname, &block)
         end
@@ -42,20 +42,20 @@ if defined?(ActiveSupport::Logger::SimpleFormatter)
       # If a newline is necessary then create a new message ending with a newline.
       # Ensures that the original message is not mutated.
       message = "#{message}\n" unless message[-1] == "\n"
-      if (defined?(Imprint::Tracer)) && message && message.is_a?(String) && message.length > 1 && Imprint::Tracer.get_trace_id && !message.include?('trace_id=')
-        message = message.gsub("\n"," trace_id=#{Imprint::Tracer.get_trace_id}\n")
+      if defined?(Imprint::Tracer)
+        Imprint::Tracer.insert_trace_id_in_message(message)
       end
       message
     end
   end
-  
+
   #Rails 4 production newly generated apps
   class Logger::Formatter
     def call(severity, time, progname, msg)
       message = msg2str(msg)
       message = "#{message}\n" unless message[-1] == "\n"
-      if (defined?(Imprint::Tracer)) && message && message.is_a?(String) && message.length > 1 && Imprint::Tracer.get_trace_id && !message.include?('trace_id=')
-        message = message.gsub("\n"," trace_id=#{Imprint::Tracer.get_trace_id}\n")
+      if defined?(Imprint::Tracer)
+        Imprint::Tracer.insert_trace_id_in_message(message)
       end
       Format % [severity[0..0], format_datetime(time), $$, severity, progname, message]
     end

data/lib/imprint/tracer.rb

@@ -3,6 +3,7 @@ module Imprint
     TRACER_HEADER    = 'HTTP_IMPRINTID'
     TRACER_KEY       = 'IMPRINTID'
     RAILS_REQUEST_ID = "action_dispatch.request_id"
+    TRACE_ID_DEFAULT = -1
 
     TRACE_CHARS = [('a'..'z'), ('A'..'Z')].map { |i| i.to_a }.flatten
 
@@ -13,11 +14,23 @@ module Imprint
     end
 
     def self.get_trace_id
-      Thread.current[TRACER_KEY]
+      if Thread.current.key?(TRACER_KEY)
+        Thread.current[TRACER_KEY]
+      else
+        TRACE_ID_DEFAULT
+      end
+    end
+
+    def self.insert_trace_id_in_message(message)
+      if message && message.is_a?(String) &&
+          message.length > 1 && !message.include?('trace_id=') &&
+          trace_id = get_trace_id && trace_id != TRACE_ID_DEFAULT
+        message.gsub!("\n"," trace_id=#{trace_id}\n")
+      end
     end
 
     def self.rand_trace_id
-      (0...6).map { TRACE_CHARS[rand(TRACE_CHARS.length)] }.join    
+      (0...6).map { TRACE_CHARS[rand(TRACE_CHARS.length)] }.join
     end
   end
 end

data/lib/imprint/version.rb

@@ -1,3 +1,3 @@
 module Imprint
-  VERSION = "1.3.0"
+  VERSION = "1.4.0"
 end

data/test/test_helper.rb

@@ -1,8 +1,7 @@
 require 'rubygems'
 require 'simplecov'
-require 'test/unit'
+require 'minitest/autorun'
 require 'shoulda'
-require 'mocha/setup'
 require 'rack'
 
 SimpleCov.start do
@@ -13,6 +12,12 @@ end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
-Mocha::Configuration.prevent(:stubbing_non_existent_method)
 
 require 'imprint'
+
+class Minitest::Test
+  def before_setup
+    # Remove any existing trace id before each test
+    Imprint::Tracer.set_trace_id nil
+  end
+end

data/test/unit/log_helpers_test.rb

@@ -1,5 +1,6 @@
-require File.expand_path('../test_helper', File.dirname(__FILE__))
+require File.expand_path('../../test_helper', __FILE__)
 require 'imprint/log_helpers'
+require 'logger'
 
 ####
 # Testing Rails integration without Rails isn't fun
@@ -21,6 +22,15 @@ end
 
 class Rails
   def self.application
+    @app ||= Object.new.tap do |app|
+      def app.config
+        @config ||= Object.new.tap do |config|
+          def config.filter_parameters
+            []
+          end
+        end
+      end
+    end
   end
 end
 
@@ -30,19 +40,32 @@ class Time
   end
 end
 
-class LogHelpersTest < Test::Unit::TestCase
+class LogHelpersTest < Minitest::Test
   include Imprint::LogHelpers
   Imprint.configure({})
 
   should "log entry" do
-    stub_rails
-    logger.expects(:info).with(anything).once
-    log_entrypoint
+    count           = 0
+    increment_count = Proc.new { count += 1 }
+
+    logger.stub :info, increment_count do
+      log_entrypoint
+    end
+
+    assert_equal 1, count
   end
 
   should "log entry catches exceptions and logs them" do
-    logger.expects(:error).with(anything).once
-    log_entrypoint
+    Imprint.stub :configuration, nil do
+      count           = 0
+      increment_count = Proc.new { count += 1 }
+
+      logger.stub :error, increment_count do
+        log_entrypoint
+      end
+
+      assert_equal 2, count
+    end
   end
 
   protected
@@ -77,16 +100,8 @@ class LogHelpersTest < Test::Unit::TestCase
     request
   end
 
-  def stub_rails
-    rails_config ||= mock('config')
-    rails_config.stubs(:filter_parameters).returns([])
-    rails_app ||= mock('application')
-    rails_app.stubs(:config).returns(rails_config)
-    Rails.stubs(:application).returns(rails_app)
-  end
-
   def logger
-    @fake_log ||= mock('logger')
+    @fake_log ||= Logger.new(STDOUT)
   end
 
   def cookies

data/test/unit/middleware_test.rb

@@ -1,10 +1,21 @@
-require File.expand_path('../test_helper', File.dirname(__FILE__))
+require File.expand_path('../../test_helper', __FILE__)
 
-class MiddlewareTest < Test::Unit::TestCase
+class MiddlewareTest < Minitest::Test
+
+  def setup
+    @logger = Minitest::Mock.new
+    Imprint::Middleware.logger = @logger
+  end
+
+  def teardown
+    Imprint::Middleware.logger = nil
+    @logger.verify
+  end
 
   should "call app" do
     request = Rack::MockRequest.env_for("/anything.json")
     middleware = Imprint::Middleware.new(fake_app)
+    @logger.expect(:info, nil) { true }
     results = middleware.call(request)
     assert_equal "/anything.json", results.last
   end
@@ -12,16 +23,18 @@ class MiddlewareTest < Test::Unit::TestCase
   should 'pass all rack lint checks' do
     app = Rack::Lint.new(Imprint::Middleware.new(fake_app))
     env = Rack::MockRequest.env_for('/hello')
+    @logger.expect(:info, nil) { true }
     app.call(env)
   end
 
   should "set trace_id before calling app" do
     request = Rack::MockRequest.env_for("/anything.json")
     middleware = Imprint::Middleware.new(fake_app)
+    @logger.expect(:info, nil) {|x| x=~ /trace_status=initiated/ }
+
     results = middleware.call(request)
     assert_equal "/anything.json", results.last
-    assert_not_nil ::Imprint::Tracer.get_trace_id
-    assert ::Imprint::Tracer.get_trace_id!='-1'
+    assert ::Imprint::Tracer.get_trace_id != ::Imprint::Tracer::TRACE_ID_DEFAULT
   end
 
   should "set trace_id from rails request_id" do
@@ -29,8 +42,8 @@ class MiddlewareTest < Test::Unit::TestCase
     middleware = Imprint::Middleware.new(fake_app)
     results = middleware.call(request)
     assert_equal "/anything.json", results.last
-    assert_not_nil ::Imprint::Tracer.get_trace_id
-    assert ::Imprint::Tracer.get_trace_id=='existing_id'
+    refute_nil ::Imprint::Tracer.get_trace_id
+    assert_equal 'existing_id', ::Imprint::Tracer.get_trace_id
   end
 
   should "set trace_id from passed in imprint header" do
@@ -38,8 +51,8 @@ class MiddlewareTest < Test::Unit::TestCase
     middleware = Imprint::Middleware.new(fake_app)
     results = middleware.call(request)
     assert_equal "/anything.json", results.last
-    assert_not_nil ::Imprint::Tracer.get_trace_id
-    assert ::Imprint::Tracer.get_trace_id=='existing_trace_id'
+    refute_nil ::Imprint::Tracer.get_trace_id
+    assert_equal 'existing_trace_id', ::Imprint::Tracer.get_trace_id
   end
 
   private

data/test/unit/tracer_test.rb

@@ -1,6 +1,6 @@
-require File.expand_path('../test_helper', File.dirname(__FILE__))
+require File.expand_path('../../test_helper', __FILE__)
 
-class TracerTest < Test::Unit::TestCase
+class TracerTest < Minitest::Test
 
   should "set trace id" do
     fake_trace = "tracer"
@@ -9,14 +9,16 @@ class TracerTest < Test::Unit::TestCase
   end
 
   should "get trace id defaults" do
-    assert_not_nil Imprint::Tracer.get_trace_id
+    assert_equal Imprint::Tracer::TRACE_ID_DEFAULT, Imprint::Tracer.get_trace_id
+    Imprint::Tracer.set_trace_id("fake_trace", fake_rack_env)
+    refute_nil Imprint::Tracer.get_trace_id
     Imprint::Tracer.set_trace_id(nil, fake_rack_env)
-    assert_equal nil, Imprint::Tracer.get_trace_id
+    assert_equal Imprint::Tracer::TRACE_ID_DEFAULT, Imprint::Tracer.get_trace_id
   end
 
   should "generate rand trace id" do
     trace_id = Imprint::Tracer.rand_trace_id
-    assert_not_nil trace_id
+    refute_nil trace_id
     assert_equal 6, trace_id.length
     assert trace_id.match(/[A-Za-z]/)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: imprint
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-11 00:00:00.000000000 Z
+date: 2014-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -43,22 +43,6 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.14.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.14.0
 - !ruby/object:Gem::Dependency
   name: shoulda
   requirement: !ruby/object:Gem::Requirement
@@ -147,7 +131,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1390655757384157980
+      hash: 1702384810650900036
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -156,7 +140,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1390655757384157980
+      hash: 1702384810650900036
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23