activesupport 2.3.18 → 3.0.0.beta

data/CHANGELOG

@@ -1,81 +1,58 @@
-## Rails 2.3.15 (Jan 8, 2012) ##
+*Rails 3.0 (pending)*
 
-* Hash.from_xml raises when it encounters type="symbol" or type="yaml". Use Hash.from_trusted_xml to parse this XML. CVE-2013-0156 [Jeremy Kemper]
+* Introduce class_attribute to declare inheritable class attributes. Writing an attribute on a subclass behaves just like overriding the superclass reader method.  Unifies and replaces most usage of cattr_accessor, class_inheritable_attribute, superclass_delegating_attribute, and extlib_inheritable_attribute.  [Jeremy Kemper, Yehuda Katz]
 
+* Time#- with a DateTime argument behaves the same as with a Time argument, i.e. returns the difference between self and arg as a Float #3476 [Geoff Buesing]
 
-*2.3.11 (February 9, 2011)*
-
-
-*2.3.10 (October 15, 2010)*
-
-
-*2.3.9 (September 4, 2010)*
-
-* i18n: bundle i18n 0.4.1 for forward compatibility with Rails 3. Deprecates {{foo}} interpolation syntax in favor of 1.9-native %{foo}.
-
-* Deprecate Kernel#returning in favor of Object#tap since it's included in Ruby 1.8.7 and later. [Santiago Pastorino]
-
-* Deprecates ActiveSupport::Dependencies.load_(once_)paths, renamed to autoload_(once_)paths. [fxn]
-
-* Deprecates Array#random_element, renamed to sample to match Ruby 1.9, thanks to Marc-Andre Lafortune. [fxn]
-
-
-*2.3.8 (May 24, 2010)*
-
-* Version bump.
-
-
-*2.3.7 (May 24, 2010)*
-
-* HTML safety: fix compatibility with the optional rails_xss plugin.  [Nathan Weizenbaum, Santiago Pastorino]
-
+* YAML serialization for OrderedHash.  #3608 [Gregor Schmidt]
 
-*2.3.6 (May 23, 2010)*
+* Update bundled TZInfo to v0.3.16 [Geoff Buesing]
 
-* 1.9 compat: deprecated last_(month|year) in favor of prev_(month|year). [fxn]
+* Georgetown TimeZone is now mapped to "America/Guyana" instead of "America/Argentina/San_Juan" #1821 [Geoff Buesing, Reuben Sivan]
 
-* Deprecated Array#rand in favor of Array#random_element. [Santiago Pastorino, Rizwan Reza]
+* Changed the default ActiveSupport.use_standard_json_time_format from false to true and
+ActiveSupport.escape_html_entities_in_json from true to false to match previously announced Rails 3 defaults [DHH]
 
 * Added Object#presence that returns the object if it's #present? otherwise returns nil [DHH/Colin Kelley]
 
-* New assertions assert_blank and assert_present.  #4299 [Juanjo Bazan]
-
-* Use Object#singleton_class instead of #metaclass. Prefer Ruby's choice.  [Jeremy Kemper]
-
-* JSON backend for YAJL. Preferred if available.  #2666 [Brian Lopez]
-
-* Introduce String#html_safe for rails_xss plugin and forward-compatibility with Rails 3.  [Michael Koziarski, Santiago Pastorino, José Ignacio Costa]
-
-* Time#- with a DateTime argument behaves the same as with a Time argument, i.e. returns the difference between self and arg as a Float #3476 [Geoff Buesing]
+* Add Enumerable#exclude? to bring parity to Enumerable#include? and avoid if !x.include?/else calls [DHH]
 
-* YAML serialization for OrderedHash.  #3608 [Gregor Schmidt]
+* Update Edinburgh TimeZone to use "Europe/London" instead of "Europe/Dublin" #3310 [Phil Ross]
 
-* Add Enumerable#exclude? to bring parity to Enumerable#include? and avoid if !x.include?/else calls [DHH]
+* Update bundled TZInfo to v0.3.15 [Geoff Buesing]
 
+* JSON: +Object#to_json+ calls +as_json+ to coerce itself into something natively encodable like +Hash+, +Integer+, or +String+. Override +as_json+ instead of +to_json+ so you're JSON library agnostic.  [Jeremy Kemper]
 
-*2.3.5 (November 25, 2009)*
+* String #to_time and #to_datetime: handle fractional seconds #864 [Jason Frey]
 
-* Minor Bug Fixes and deprecation warnings
+* Update bundled TZInfo to v0.3.13 [Geoff Buesing]
 
-* Update Edinburgh TimeZone to use "Europe/London" instead of "Europe/Dublin" #3310 [Phil Ross]
+* Allow MemCacheStore to be initialized with a MemCache-like object instead of addresses and options [Bryan Helmkamp]
 
-* Fixes for the Nokogiri backend for XmlMini
+* Change spelling of Kyev timezone to Kyiv #2613 [Alexander Dymo]
 
-* Ruby 1.9 Compatibility
+* Add ActiveSupport.parse_json_times to disable time parsing in JSON backends that don't support it or don't need it. [rick]
 
+* Add pluggable JSON backends with support for the JSON gem. [rick]
+    Example: ActiveSupport::JSON.backend = "JSONGem"
 
-*2.3.4 (September 4, 2009)*
+ All internal Rails JSON encoding is now handled by ActiveSupport::JSON.encode().  Use of #to_json is not recommended, as it may clash with other libraries that overwrite it.  However, you can recover Rails specific functionality
+ if you really want to use #to_json.
 
-* Introduce ActiveSupport::Multibyte.clean to clean invalid multibyte strings.
+    gem 'json'
+    ActiveSupport::JSON.backend = "JSONGem"
 
-* Bug fixes
+    class ActiveRecord::Base
+      alias to_json rails_to_json
+    end
 
+* require 'active_support' no longer orders the whole menu of core extensions. Ask for just what you need: e.g. require 'active_support/core/time' to use timezones, durations, and stdlib date/time extensions. [Jeremy Kemper]
 
-*2.3.3 (July 12, 2009)*
+* Removed rarely-used DRb cache store.  [Jeremy Kemper]
 
-* JSON: +Object#to_json+ calls +as_json+ to coerce itself into something natively encodable like +Hash+, +Integer+, or +String+. Override +as_json+ instead of +to_json+ so you're JSON-library-agnostic.  [Jeremy Kemper]
+* TimeWithZone.name returns 'Time', to further thwart type checking [Geoff Buesing]
 
-* Allow MemCacheStore to be initialized with a MemCache-like object instead of addresses and options [Bryan Helmkamp]
+* Time.local instances: Adding 24.hours across the DST boundary adds 24 hours instead of one day #2066 [Michael Curtis]
 
 
 *2.3.2 [Final] (March 15, 2009)*

data/lib/active_support.rb

@@ -22,39 +22,51 @@
 #++
 
 module ActiveSupport
-  def self.load_all!
-    [Dependencies, Deprecation, Gzip, MessageVerifier, Multibyte, SecureRandom, TimeWithZone]
+  class << self
+    attr_accessor :load_all_hooks
+    def on_load_all(&hook) load_all_hooks << hook end
+    def load_all!; load_all_hooks.each { |hook| hook.call } end
   end
+  self.load_all_hooks = []
 
-  autoload :BacktraceCleaner, 'active_support/backtrace_cleaner'
-  autoload :Base64, 'active_support/base64'
-  autoload :BasicObject, 'active_support/basic_object'
-  autoload :BufferedLogger, 'active_support/buffered_logger'
-  autoload :Cache, 'active_support/cache'
-  autoload :Callbacks, 'active_support/callbacks'
-  autoload :Deprecation, 'active_support/deprecation'
-  autoload :Duration, 'active_support/duration'
-  autoload :Gzip, 'active_support/gzip'
-  autoload :Inflector, 'active_support/inflector'
-  autoload :Memoizable, 'active_support/memoizable'
-  autoload :MessageEncryptor, 'active_support/message_encryptor'
-  autoload :MessageVerifier, 'active_support/message_verifier'
-  autoload :Multibyte, 'active_support/multibyte'
-  autoload :OptionMerger, 'active_support/option_merger'
-  autoload :OrderedHash, 'active_support/ordered_hash'
-  autoload :OrderedOptions, 'active_support/ordered_options'
-  autoload :Rescuable, 'active_support/rescuable'
-  autoload :SafeBuffer, 'active_support/core_ext/string/output_safety'
-  autoload :SecureRandom, 'active_support/secure_random'
-  autoload :StringInquirer, 'active_support/string_inquirer'
-  autoload :TimeWithZone, 'active_support/time_with_zone'
-  autoload :TimeZone, 'active_support/values/time_zone'
-  autoload :XmlMini, 'active_support/xml_mini'
+  on_load_all do
+    [Dependencies, Deprecation, Gzip, MessageVerifier, Multibyte, SecureRandom]
+  end
 end
 
-require 'active_support/vendor'
-require 'active_support/core_ext'
-require 'active_support/dependencies'
-require 'active_support/json'
+require "active_support/dependencies/autoload"
+
+module ActiveSupport
+  extend ActiveSupport::Autoload
+
+  # TODO: Narrow this list down
+  eager_autoload do
+    autoload :BacktraceCleaner
+    autoload :Base64
+    autoload :BasicObject
+    autoload :Benchmarkable
+    autoload :BufferedLogger
+    autoload :Cache
+    autoload :Callbacks
+    autoload :Concern
+    autoload :Configurable
+    autoload :Deprecation
+    autoload :Gzip
+    autoload :Inflector
+    autoload :Memoizable
+    autoload :MessageEncryptor
+    autoload :MessageVerifier
+    autoload :Multibyte
+    autoload :OptionMerger
+    autoload :OrderedHash
+    autoload :OrderedOptions
+    autoload :Notifications
+    autoload :Rescuable
+    autoload :SecureRandom
+    autoload :StringInquirer
+    autoload :XmlMini
+  end
 
-I18n.load_path << "#{File.dirname(__FILE__)}/active_support/locale/en.yml"
+  autoload :SafeBuffer, "active_support/core_ext/string/output_safety"
+  autoload :TestCase
+end

data/lib/active_support/all.rb

@@ -1,8 +1,4 @@
-# For forward compatibility with Rails 3.
-#
-# require 'active_support' loads a very bare minumum in Rails 3.
-# require 'active_support/all' loads the whole suite like Rails 2 did.
-#
-# To prepare for Rails 3, switch to require 'active_support/all' now.
-
 require 'active_support'
+require 'active_support/i18n'
+require 'active_support/time'
+require 'active_support/core_ext'

data/lib/active_support/backtrace_cleaner.rb

@@ -9,7 +9,7 @@ module ActiveSupport
   # Example:
   #
   #   bc = BacktraceCleaner.new
-  #   bc.add_filter   { |line| line.gsub(Rails.root, '') } 
+  #   bc.add_filter   { |line| line.gsub(Rails.root, '') }
   #   bc.add_silencer { |line| line =~ /mongrel|rubygems/ }
   #   bc.clean(exception.backtrace) # will strip the Rails.root prefix and skip any lines from mongrel or rubygems
   #
@@ -18,10 +18,19 @@ module ActiveSupport
     def initialize
       @filters, @silencers = [], []
     end
-    
+
     # Returns the backtrace after all filters and silencers has been run against it. Filters run first, then silencers.
-    def clean(backtrace)
-      silence(filter(backtrace))
+    def clean(backtrace, kind = :silent)
+      filtered = filter(backtrace)
+
+      case kind
+      when :silent
+        silence(filtered)
+      when :noise
+        noise(filtered)
+      else
+        filtered
+      end
     end
 
     # Adds a filter from the block provided. Each line in the backtrace will be mapped against this filter.
@@ -51,21 +60,28 @@ module ActiveSupport
       @silencers = []
     end
 
-    
     private
       def filter(backtrace)
         @filters.each do |f|
           backtrace = backtrace.map { |line| f.call(line) }
         end
-        
+
         backtrace
       end
-      
+
       def silence(backtrace)
         @silencers.each do |s|
           backtrace = backtrace.reject { |line| s.call(line) }
         end
-        
+
+        backtrace
+      end
+
+      def noise(backtrace)
+        @silencers.each do |s|
+          backtrace = backtrace.select { |line| s.call(line) }
+        end
+
         backtrace
       end
   end

data/lib/active_support/base64.rb

@@ -30,4 +30,13 @@ module ActiveSupport
       end
     end
   end
+
+  # Encodes the value as base64 without the newline breaks. This makes the base64 encoding readily usable as URL parameters
+  # or memcache keys without further processing.
+  #
+  #  ActiveSupport::Base64.encode64s("Original unencoded string")
+  #  # => "T3JpZ2luYWwgdW5lbmNvZGVkIHN0cmluZw=="
+  def Base64.encode64s(value)
+    encode64(value).gsub(/\n/, '')
+  end
 end

data/lib/active_support/benchmarkable.rb

@@ -0,0 +1,60 @@
+require 'active_support/core_ext/benchmark'
+require 'active_support/core_ext/hash/keys'
+
+module ActiveSupport
+  module Benchmarkable
+    # Allows you to measure the execution time of a block 
+    # in a template and records the result to the log. Wrap this block around
+    # expensive operations or possible bottlenecks to get a time reading
+    # for the operation.  For example, let's say you thought your file 
+    # processing method was taking too long; you could wrap it in a benchmark block.
+    #
+    #  <% benchmark "Process data files" do %>
+    #    <%= expensive_files_operation %>
+    #  <% end %>
+    #
+    # That would add something like "Process data files (345.2ms)" to the log,
+    # which you can then use to compare timings when optimizing your code.
+    #
+    # You may give an optional logger level as the :level option.
+    # (:debug, :info, :warn, :error); the default value is :info.
+    #
+    #  <% benchmark "Low-level files", :level => :debug do %>
+    #    <%= lowlevel_files_operation %>
+    #  <% end %>
+    #
+    # Finally, you can pass true as the third argument to silence all log activity 
+    # inside the block. This is great for boiling down a noisy block to just a single statement:
+    #
+    #  <% benchmark "Process data files", :level => :info, :silence => true do %>
+    #    <%= expensive_and_chatty_files_operation %>
+    #  <% end %>
+    def benchmark(message = "Benchmarking", options = {})
+      if logger
+        if options.is_a?(Symbol)
+          ActiveSupport::Deprecation.warn("use benchmark('#{message}', :level => :#{options}) instead", caller)
+          options = { :level => options, :silence => false }
+        else
+          options.assert_valid_keys(:level, :silence)
+          options[:level] ||= :info
+        end
+
+        result = nil
+        ms = Benchmark.ms { result = options[:silence] ? logger.silence { yield } : yield }
+        logger.send(options[:level], '%s (%.1fms)' % [ message, ms ])
+        result
+      else
+        yield
+      end
+    end
+
+    # Silence the logger during the execution of the block.
+    #
+    def silence
+      old_logger_level, logger.level = logger.level, ::Logger::ERROR if logger
+      yield
+    ensure
+      logger.level = old_logger_level if logger
+    end
+  end
+end

data/lib/active_support/buffered_logger.rb

@@ -1,4 +1,4 @@
-require 'thread'
+require 'active_support/core_ext/class/attribute_accessors'
 
 module ActiveSupport
   # Inspired by the buffered logger idea by Ezra
@@ -53,7 +53,6 @@ module ActiveSupport
         FileUtils.mkdir_p(File.dirname(log))
         @log = open(log, (File::WRONLY | File::APPEND | File::CREAT))
         @log.sync = true
-        @log.write("# Logfile created on %s" % [Time.now.to_s])
       end
     end
 
@@ -68,15 +67,19 @@ module ActiveSupport
       message
     end
 
+    # Dynamically add methods such as:
+    # def info
+    # def warn
+    # def debug
     for severity in Severity.constants
       class_eval <<-EOT, __FILE__, __LINE__ + 1
-        def #{severity.downcase}(message = nil, progname = nil, &block)  # def debug(message = nil, progname = nil, &block)
-          add(#{severity}, message, progname, &block)                    #   add(DEBUG, message, progname, &block)
-        end                                                              # end
-                                                                         #
-        def #{severity.downcase}?                                        # def debug?
-          #{severity} >= @level                                          #   DEBUG >= @level
-        end                                                              # end
+        def #{severity.downcase}(message = nil, progname = nil, &block) # def debug(message = nil, progname = nil, &block)
+          add(#{severity}, message, progname, &block)                   #   add(DEBUG, message, progname, &block)
+        end                                                             # end
+
+        def #{severity.downcase}?                                       # def debug?
+          #{severity} >= @level                                         #   DEBUG >= @level
+        end                                                             # end
       EOT
     end
 

data/lib/active_support/cache.rb

@@ -1,4 +1,10 @@
 require 'benchmark'
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/benchmark'
+require 'active_support/core_ext/exception'
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/object/to_param'
+require 'active_support/core_ext/string/inflections'
 
 module ActiveSupport
   # See ActiveSupport::Cache::Store for documentation.
@@ -6,7 +12,6 @@ module ActiveSupport
     autoload :FileStore, 'active_support/cache/file_store'
     autoload :MemoryStore, 'active_support/cache/memory_store'
     autoload :SynchronizedMemoryStore, 'active_support/cache/synchronized_memory_store'
-    autoload :DRbStore, 'active_support/cache/drb_store'
     autoload :MemCacheStore, 'active_support/cache/mem_cache_store'
     autoload :CompressedMemCacheStore, 'active_support/cache/compressed_mem_cache_store'
 
@@ -25,9 +30,9 @@ module ActiveSupport
     #
     #   ActiveSupport::Cache.lookup_store(:memory_store)
     #   # => returns a new ActiveSupport::Cache::MemoryStore object
-    #   
-    #   ActiveSupport::Cache.lookup_store(:drb_store)
-    #   # => returns a new ActiveSupport::Cache::DRbStore object
+    #
+    #   ActiveSupport::Cache.lookup_store(:mem_cache_store)
+    #   # => returns a new ActiveSupport::Cache::MemCacheStore object
     #
     # Any additional arguments will be passed to the corresponding cache store
     # class's constructor:
@@ -40,11 +45,11 @@ module ActiveSupport
     #   ActiveSupport::Cache.lookup_store(MyOwnCacheStore.new)
     #   # => returns MyOwnCacheStore.new
     def self.lookup_store(*store_option)
-      store, *parameters = *([ store_option ].flatten)
+      store, *parameters = *Array.wrap(store_option).flatten
 
       case store
       when Symbol
-        store_class_name = (store == :drb_store ? "DRbStore" : store.to_s.camelize)
+        store_class_name = store.to_s.camelize
         store_class = ActiveSupport::Cache.const_get(store_class_name)
         store_class.new(*parameters)
       when nil
@@ -54,19 +59,27 @@ module ActiveSupport
       end
     end
 
+    RAILS_CACHE_ID   = ENV["RAILS_CACHE_ID"]
+    RAILS_APP_VERION = ENV["RAILS_APP_VERION"]
+    EXPANDED_CACHE   = RAILS_CACHE_ID || RAILS_APP_VERION
+
     def self.expand_cache_key(key, namespace = nil)
       expanded_cache_key = namespace ? "#{namespace}/" : ""
 
-      if ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]
-        expanded_cache_key << "#{ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]}/"
+      if EXPANDED_CACHE
+        expanded_cache_key << "#{RAILS_CACHE_ID || RAILS_APP_VERION}/"
       end
 
-      expanded_cache_key << case
-        when key.respond_to?(:cache_key)
+      expanded_cache_key <<
+        if key.respond_to?(:cache_key)
           key.cache_key
-        when key.is_a?(Array)
-          key.collect { |element| expand_cache_key(element) }.to_param
-        when key
+        elsif key.is_a?(Array)
+          if key.size > 1
+            key.collect { |element| expand_cache_key(element) }.to_param
+          else
+            key.first.to_param
+          end
+        elsif key
           key.to_param
         end.to_s
 
@@ -84,23 +97,21 @@ module ActiveSupport
     # Ruby objects, but don't count on every cache store to be able to do that.
     #
     #   cache = ActiveSupport::Cache::MemoryStore.new
-    #   
+    #
     #   cache.read("city")   # => nil
     #   cache.write("city", "Duckburgh")
     #   cache.read("city")   # => "Duckburgh"
     class Store
-      cattr_accessor :logger
+      cattr_accessor :logger, :instance_writter => false
 
-      attr_reader :silence, :logger_off
+      attr_reader :silence
+      alias :silence? :silence
 
       def silence!
         @silence = true
         self
       end
 
-      alias silence? silence
-      alias logger_off? logger_off
-
       def mute
         previous_silence, @silence = defined?(@silence) && @silence, true
         yield
@@ -108,6 +119,15 @@ module ActiveSupport
         @silence = previous_silence
       end
 
+      # Set to true if cache stores should be instrumented. By default is false.
+      def self.instrument=(boolean)
+        Thread.current[:instrument_cache_store] = boolean
+      end
+
+      def self.instrument
+        Thread.current[:instrument_cache_store] || false
+      end
+
       # Fetches data from the cache, using the given key. If there is data in
       # the cache with the given key, then that data is returned.
       #
@@ -119,7 +139,7 @@ module ActiveSupport
       #
       #   cache.write("today", "Monday")
       #   cache.fetch("today")  # => "Monday"
-      #   
+      #
       #   cache.fetch("city")   # => nil
       #   cache.fetch("city") do
       #     "Duckburgh"
@@ -138,8 +158,8 @@ module ActiveSupport
       #
       # For example, MemCacheStore's #write method supports the +:expires_in+
       # option, which tells the memcached server to automatically expire the
-      # cache item after a certain period. We can use this option with #fetch
-      # too:
+      # cache item after a certain period. This options is also supported by
+      # FileStore's #read method. We can use this option with #fetch too:
       #
       #   cache = ActiveSupport::Cache::MemCacheStore.new
       #   cache.fetch("foo", :force => true, :expires_in => 5.seconds) do
@@ -148,26 +168,13 @@ module ActiveSupport
       #   cache.fetch("foo")  # => "bar"
       #   sleep(6)
       #   cache.fetch("foo")  # => nil
-      def fetch(key, options = {})
-        @logger_off = true
+      def fetch(key, options = {}, &block)
         if !options[:force] && value = read(key, options)
-          @logger_off = false
-          log("hit", key, options)
           value
         elsif block_given?
-          @logger_off = false
-          log("miss", key, options)
-
-          value = nil
-          ms = Benchmark.ms { value = yield }
-
-          @logger_off = true
-          write(key, value, options)
-          @logger_off = false
-
-          log('write (will save %.2fms)' % ms, key, nil)
-
-          value
+          result = instrument(:generate, key, options, &block)
+          write(key, result, options)
+          result
         end
       end
 
@@ -178,8 +185,12 @@ module ActiveSupport
       # You may also specify additional options via the +options+ argument.
       # The specific cache store implementation will decide what to do with
       # +options+.
-      def read(key, options = nil)
-        log("read", key, options)
+      #
+      # For example, FileStore supports the +:expires_in+ option, which
+      # makes the method return nil for cache items older than the specified
+      # period.
+      def read(key, options = nil, &block)
+        instrument(:read, key, options, &block)
       end
 
       # Writes the given value to the cache, with the given key.
@@ -187,7 +198,7 @@ module ActiveSupport
       # You may also specify additional options via the +options+ argument.
       # The specific cache store implementation will decide what to do with
       # +options+.
-      # 
+      #
       # For example, MemCacheStore supports the +:expires_in+ option, which
       # tells the memcached server to automatically expire the cache item after
       # a certain period:
@@ -197,24 +208,23 @@ module ActiveSupport
       #   cache.read("foo")  # => "bar"
       #   sleep(6)
       #   cache.read("foo")  # => nil
-      def write(key, value, options = nil)
-        log("write", key, options)
+      def write(key, value, options = nil, &block)
+        instrument(:write, key, options, &block)
       end
 
-      def delete(key, options = nil)
-        log("delete", key, options)
+      def delete(key, options = nil, &block)
+        instrument(:delete, key, options, &block)
       end
 
-      def delete_matched(matcher, options = nil)
-        log("delete matched", matcher.inspect, options)
+      def delete_matched(matcher, options = nil, &block)
+        instrument(:delete_matched, matcher.inspect, options, &block)
       end
 
-      def exist?(key, options = nil)
-        log("exist?", key, options)
+      def exist?(key, options = nil, &block)
+        instrument(:exist?, key, options, &block)
       end
 
       def increment(key, amount = 1)
-        log("incrementing", key, amount)
         if num = read(key)
           write(key, num + amount)
         else
@@ -223,7 +233,6 @@ module ActiveSupport
       end
 
       def decrement(key, amount = 1)
-        log("decrementing", key, amount)
         if num = read(key)
           write(key, num - amount)
         else
@@ -234,14 +243,25 @@ module ActiveSupport
       private
         def expires_in(options)
           expires_in = options && options[:expires_in]
-
           raise ":expires_in must be a number" if expires_in && !expires_in.is_a?(Numeric)
-
           expires_in || 0
         end
 
+        def instrument(operation, key, options)
+          log(operation, key, options)
+
+          if self.class.instrument
+            payload = { :key => key }
+            payload.merge!(options) if options.is_a?(Hash)
+            ActiveSupport::Notifications.instrument("active_support.cache_#{operation}", payload){ yield }
+          else
+            yield
+          end
+        end
+
         def log(operation, key, options)
-          logger.debug("Cache #{operation}: #{key}#{options ? " (#{options.inspect})" : ""}") if logger && !silence? && !logger_off?
+          return unless logger && !silence?
+          logger.debug("Cache #{operation}: #{key}#{options ? " (#{options.inspect})" : ""}")
         end
     end
   end