DZone Snippets: cache code

Automatic Expiration of Rails Action Caching

timmorgan (Tim Morgan) — Wed, 16 Jul 2008 03:21:22 GMT

Would love to get some feedback on this...

No doubt, 5 minutes after posting this, someone will tell me of the built-in Rails way of doing this, but alas I could not find it.

Usage looks like this:



class PeopleController < ApplicationController

  caches_action :show, :for => 1.hour, :cache_path => Proc.new { |c| "people/#{c.params[:id]}_for_#{Person.logged_in.id}" }

end

The ":for => 1.hour" part is where the magic happens.

Basically, this bit of code adds a before_filter that checks the last modified time of the cache entry, and expires it if it is older than the specified time period.



module ActionController

  module Caching

    module Fragments

      # expire a cache key only if the block returns true or

      # if the age of the fragment is more than the specified age argument.

      def expire_fragment_by_mtime(key, age=nil, &block)

        block = Proc.new { |m| m < age.ago } unless block_given?

        if (m = cache_store.mtime(fragment_cache_key(key))) and block.call(m)

          expire_fragment(key)

        end

      end

    end

    module Actions

      module ClassMethods

        # adds an option :for

        # caches_action :show, :for => 2.hours, :cache_path => ...

        # :cache_path is required, unfortunately

        def caches_action_with_for(*actions)

          original_actions = actions.clone

          options = actions.extract_options!

          if for_time = options.delete(:for)

            cache_path = options[:cache_path]

            before_filter do |controller|

              cache_path = cache_path.call(controller) if cache_path.respond_to?(:call)

              controller.expire_fragment_by_mtime(cache_path, for_time)

            end

          end

          caches_action_without_for(*original_actions)

        end

        alias_method_chain :caches_action, :for

      end

    end

  end

end



# Add a method to grab the last modified time of the cache key.

# If you use a store other than the FileStore, you'll need to add

# a method like this to your store.

module ActiveSupport

  module Cache

    class FileStore

      def mtime(name)

        File.mtime(real_file_path(name)) rescue nil

      end

    end

  end

end

Marshalize (Cache) ActiveRecord Query Results

timmorgan (Tim Morgan) — Thu, 31 Jan 2008 01:37:39 GMT

A quick way to cache results in a file and read from the file on subsequent requests instead of the database. Makes the initial query a bit slower, but later queries *much* faster.



class MyCachedModel < ActiveRecord::Base

  class << self

    alias_method :rails_original_find_by_sql, :find_by_sql

    def find_by_sql(sql)

      cache_filename = Base64.encode64(sql)

      if File.exists? cache_filename

        Marshal.load(File.open(cache_filename))

      else

        Marshal.dump(records = rails_original_find_by_sql(sql), File.open(cache_filename, 'w'))

        return records

      end

    end

  end

end

Attribute Cache

iamwil (wilhelm) — Sun, 13 May 2007 13:45:43 GMT

Sometimes, you don't want to calculate the value of an attribute every time--like the sum of an array. However, you don't want it cached on the outside of the object since that makes for messy code. But you seem to cache things over and over again inside objects. Here's a module AttributeCache that does a little meta programming to make attribute caching a little bit easier. more details at http://webjazz.blogspot.com/2007/05/ruby-snippet-caching-object-attributes.html



module AttributeCache



  def metaclass; class << self; self; end; end

  

  def cache(attr_name, options)

    instance_variable_set "@#{attr_name}", options[:initial]

    instance_variable_set "@#{:sum}_outdated", true



    metaclass.instance_eval do 

      define_method("outdate_#{attr_name}") do

        puts "in outdated"

        instance_variable_set "@#{attr_name}_outdated", true

      end

    end

    

    metaclass.class_eval %Q{

      def cached_#{attr_name}(&block)

        if @#{attr_name}_outdated

          puts "in cached to update!"

          @#{attr_name}_outdated = false

          @#{attr_name} = block.call

        else

          puts "in cached to give cache!"

        end

        return @#{attr_name}

      end

    }



  end

  

end



class Collection

  include AttributeCache



  def initialize

    @array = []

    cache :sum, :initial => 0

  end



  def add(x)

    outdate_sum

    @array << x

  end



  def sum

    cached_sum { @array.inject {|t, e| t += e} }

  end

  

end



c = Collection.new

puts c.public_methods(false).inspect

c.add(2)

c.add(3)

puts c.sum

puts c.sum

c.add(4)

puts c.sum

puts c.sum

JS cache control

ejboy (Fyodor Kupolov) — Tue, 13 Feb 2007 08:21:16 GMT

The following JSP snippet shows a simple caching policy for JS files, i.e.
the browser fetches js files when a new build is available.

qBuildNum is a build number or a repository revision suffix, e.g.?102 etc.
ServerInfoService.getBuildNumber() is a function which returns current build number. This function has to be coded manually, alternatively a servlet context attribute can be used...



<%

    String qBuildNum = '?' + ServerInfoService.getBuildNumber(); //Suffix for JS to avoid caching

%>

Rails - ‘poor mans’ SQL cache.

joeldg (joeldg) — Mon, 15 Jan 2007 22:55:31 GMT

Rails memcached is not very easy to introduce to a large rails installation. Memcached also chews up a lot of memory on the box and overall cached model does not work the way I needed it to. Basically, I have just a â€œfewâ€? queries that I needed to cache because pagination sucks just that bad in rails.
So, I built my own cache, similar to how I build them in PHP except I am not using disk cache, I am using MySQL itself to cache itâ€™s own results

First, we need a table to hold all this info (note the â€˜blobâ€™ field)



CREATE TABLE `cacheditems` (

`id` int(11) NOT NULL auto_increment,

`cachekey` varchar(255) default NULL,

`created` datetime default NULL,

`expires` datetime default NULL,

`content` longblob,

`cachehit` int(11) NOT NULL,

PRIMARY KEY  (`id`),

KEY `cacheditems_cachekey_index` (`cachekey`),

KEY `cacheditems_created_index` (`created`),

KEY `cacheditems_expires_index` (`expires`)

)

Then we create a model called â€œcacheditemâ€? which has the following functions



require 'digest/sha1'

class Cacheditem < ActiveRecord::Base



def self.checkfor(sql)

key = Digest::MD5.hexdigest(Marshal.dump(sql))

logger.info "%%% checking for key #{key}"

#logger.info "%%% checking by sql #{sql[0]}"

Cacheditem.find( :first, :conditions => [ â€œcachekey = ? AND expires > NOW()â€?, key] )

end



def self.getcached(sql)

key = Digest::MD5.hexdigest(Marshal.dump(sql))

logger.info â€œ%%% getting by key #{key}â€?

#logger.info â€œ%%% getting by sql #{sql[0]}â€?

getc = Cacheditem.find( :first, :conditions => [ â€œcachekey = ?â€?, key] )

hitcount = getc.cachehit + 1

Cacheditem.update(getc.id, {:cachehit => hitcount})

Cacheditem.delete_all â€œexpires < NOW()"  # cleaner

return Marshal.load( getc.content )

end



def self.storeresult(sql, result)

key = Digest::MD5.hexdigest(Marshal.dump(sql))

logger.info "%%% storing by key #{key}"

content = Marshal.dump(result)

logger.level = (4) # this stops display in logs of the marshal data

ci = new()

ci.cachekey    = key

ci.created       = Time.now()

ci.expires        = 30.minutes.from_now() # change as needed

ci.content        = content

ci.cachehit       = 0

ci.save

return  result

end



end

Then, in application.rb I added the following function



def find_by_sql_cache(sql)

iscached = Cacheditem.checkfor(sql)

if iscached

Cacheditem.getcached(sql)

else

result = connection.select_all(sanitize_sql(sql), "#{name} Load").collect! { |record| instantiate(record) }

Cacheditem.storeresult(sql, result)

end

end

just throw â€œ_cacheâ€? after any â€œfind_by_sqlâ€? statement you have a need to cache and there you are.

This works very fast, very well, and doesnâ€™t hog your memory. It cleans up after itself in the database, and perhaps it does that too much.. It would be easy to add in a standard garbage collection function which runs on a random but I felt this gave me much better stats of the actual thirty-minute cacheâ€¦
If you use zabbix for monitoring your network, you can have fun graphs of cache statistics by adding the following to your zabbix_agentd.conf



UserParameter=mysql.totalcache,mysql â€“batch â€“skip-column-names -D {YOUR_DATABASE} -u{YOUR_USERNAME} -p{YOUR_PASSWORD} -e â€œSELECT count( * ) AS total, SUM( cachehit ) AS amount from cacheditems;â€? | cut -f1

UserParameter=mysql.cachehits,mysql â€“batch â€“skip-column-names -D {YOUR_DATABASE} -u{YOUR_USERNAME} -p{YOUR_PASSWORD} -e â€œSELECT count( * ) AS total, SUM( cachehit ) AS amount from cacheditems;â€? | cut -f2

Time based expiration of cache fragments in Ruby on Rails (MemCacheStore and FileStore)

jacek.becela (Jacek Becela) — Mon, 06 Nov 2006 13:00:58 GMT

This allows to expire cached fragments by ttl. Example usage (in views):



<% cache("name", :ttl => 7.days) do %>

  ... some database-heavy stuff ...

<% end %>

Put the following in environment.rb or in lib/.



class ActionController::Caching::Fragments::MemCacheStore

  def write(name, value, options=nil)

    if options.is_a?(Hash) && options.has_key?(:ttl)

      ttl = options[:ttl]

    else

      ttl = 0

    end

    @data.set(name, value, ttl)

  end

end



module ActionView::Helpers::CacheHelper

  def cache(name = {}, options = nil, &block)

    @controller.cache_erb_fragment(block, name, options)

  end

end



class ActionController::Caching::Fragments::UnthreadedFileStore

  def read(name, options = nil) 

    if options.is_a?(Hash) && options.has_key?(:ttl)

      ttl = options[:ttl]

    else

      ttl = 0

    end



    fn = real_file_path(name)



    # if cache expired act as if file doesn't exist

    return if ttl > 0 && File.exists?(fn) && (File.mtime(fn) < (Time.now - ttl))



    File.open(fn, 'rb') { |f| f.read } rescue nil

  end

end

Clear DNS lookup / IP address cache on OS X Tiger

peter (Peter Cooperx) — Thu, 25 Aug 2005 06:37:15 GMT

lookupd -flushcache