So anyway, I am one of those laggards and only wrote a Rails Metal piece not too long ago for a Rails app on Wego.com in an effort to optimize some high volume requests. It looked something like this:

class Adamantine
  def self.call(env)
    if env['PATH_INFO'] =~ ROUTE_REGEX
      location = Location.find(1) # Use ActiveRecord.

      [200, { 'Content-Type' => 'text/html' }, [location.to_json]]
    else
      # Leave it to Rails to deal with the request.
      [404, { 'Content-Type' => 'text/html' }, ['Not Found']]
    end
  end
end

Notice the use of an ActiveRecord model. It ran for quite awhile, almost 30 minutes, in production until I started getting notification emails about “Too many open database connections” to the MySQL server! The change was promptly rolled back and there was no cheezburger for me.

As it turns out, Rails doesn’t take care of certain things in Rails Metal pieces, including the releasing of connections back to the database connection pool. A bit of googling turned up this bug in Rails’ bug tracker (see Josh Peek’s comment about ActiveRecord::Base.clear_active_connections!).

I rewrote the Rails Metal piece to always ensure it clears any active database connections with ActiveRecord::Base.clear_active_connections!:

class Adamantine
  def self.call(env)
    if env['PATH_INFO'] =~ ROUTE_REGEX
      location = Location.find(1)

      [200, { 'Content-Type' => 'text/html' }, [location.to_json]]
    else
      # Leave it to Rails to deal with the request.
      [404, { 'Content-Type' => 'text/html' }, ['Not Found']]
    end
  ensure
    # Release the connections back to the pool.
    ActiveRecord::Base.clear_active_connections!
  end
end

Moral of the story: Don’t forget to release your database connections if you’re using ActiveRecord in your Rails Metal. Or even better, don’t use ActiveRecord in Rails Metal – you’re aiming for raw speed anyway right?

Catch the new first edition – this one’s about the API changes since Rails 2.1.

Here’s a shot of Portland Convention Center where it’s all happening:

There’re queues for collection of badges after registering your attendance:

Patience in the queue rewarded me with a RailsConf badge/name tag:

I was at the Meta-programming Ruby for Fun & Profit tutorial in the morning. I think when I selected the tutorial it was before I’d seen Neal Ford and Patrick Farley’s (the speakers) presentation videos from elsewhere – I know Patrick presented at MWRC and enjoyed that video.

So anyway, after the break I went over to the Refactoring Your Rails Application tutorial. Was pretty good, but I didn’t learn much I didn’t already know.

Lunch came in the form of a pretty box:

After lunch was the 2nd tutorial session and I went to both CI for the Rails Guy (or Gal) (by Chad Woolley) and Developer Testing Tricks (by Brian Takita). There were some scathing comments about how the tutorials were rather underwhelming so far in #railsconf on IRC. While I agree that the tutorials were rather underwhelming, I think I should have expected it. Oh well, I’ll know to skip them next time.

Later that night, at the Birds of a Feather session, after stealing a Pivotal Labs t-shirt (they’re launching a bug tracker, project management type app called Pivotal Tracker at RailsConf), Yehuda Katz (Merb and jQuery ninja) gave a presentation on Merb (geared towards Rails folks). It was a pretty interesting talk though there wasn’t much above what Ezra had presented previously at GoRuCo 2008 and at MWRC 2008 (I think Yehuda did one too but I can’t remember where now). Yehuda pointed out a (heated) discussion that happened recently on keeping Merb syntax as Rails-friendly as possible. I have no objection against a different syntax really, especially since Merb looks pretty well-documented in the source itself – would be nice if someone could point out an up-to-date Merb tutorial though.

Anyway, that’s it from me – as always, if anyone who reads my blog recognizes me at RailsConf, do say hi (#railsconf works too).

I’ll be at (my first) Railsconf 2008 in Portland, Oregon this Thursday onwards – if anyone sees me and recognizes me from my Facebook picture please come and say hi (no head butting though).

This week’s report covers changes from 19th May 2008 to 25th May 2008 (the day the corresponding Rails Envy podcast was recorded).

first and last methods now work with associations and named_scope

Remember how the merging of the has_finder gem into Rails allowed you to do things like Post.first and Post.last?

Now you can go one step further and use the same methods on your ActiveRecord associations. For example:

post = Post.find(1)
first_comment = post.comments.first

If you have a named_scope named recent defined, you can even do this:

post.comments.recent.last

This neat little enhancement is courtesy of Ryan Bates (yes, that Ryan Bates of Railscasts fame).

Related changeset: http://github.com/rails/rails/commit/73c59638549686fccc749ffd3ac53cb533c5fd61

Cache stores now have an exist? method and controllers get fragment_exist?

The cache stores in Rails (Memcache, file stores, etc.) now have an exist? method that checks whether a cached value exists given a cache key. This allows Rails controllers to expose a fragment_exist?
method that allows you to check for existence of a cache fragment:

fragment_exist?('example.com/foo/bar')

This little enhancement is courtesy of José Valim.

Related changeset: http://github.com/rails/rails/commit/99860b72aebe0348f41e82d4710343498d89a84b#diff-2

Create association records with block argument

You can now create records for associations like so:

post.coments.create!(:title => 'Techcrunch') do |c|
  c.body = "Rails can't scale"
end

This is in keeping with the ActiveRecord::Base.create change previously mentioned.

Credit for this patch goes (once again) to Ryan Bates.

Related changeset: http://github.com/rails/rails/commit/6cba97d2a449faf21aec9fe9d4434067e414226f

As always, let me know of any suggestions or how I can improve the Living on the Edge (of Rails) series.

This week’s report covers changes from 12th May 2008 to 18th May 2008 (the day the corresponding Rails Envy podcast was recorded).

caches_action can has conditionals

caches_action now takes an :if option (just like caches_page does). For example:

caches_action :index, :if => Proc.new { |c| !c.request.format.json? }

This little enhancement is courtesy of José Valim.

Related changeset: http://github.com/rails/rails/commit/7708650f73ddb4db300ea2059c60c1d907a4384e

Bugfix: :select option is now scanned in ActiveRecord finders to ensure needed tables are included in generated SQL

Post.find(:all, :include => :author, :select => 'posts.*, authors.id as "author_id"', :limit => 2)

Would generate an SQL statement like this:

SELECT posts.*, authors.id as "author_id" FROM "posts" LIMIT 2

Notice how the authors table is not joined. This oversight is now fixed.

Thanks go to John Devine for this bugfix.

Related changeset: http://github.com/rails/rails/commit/b28b54cab090bed8f099ef375b419a8f92390dd4

As always, let me know of any suggestions or how I can improve the Living on the Edge (of Rails) series. Also, if anyone has any recommendations of (non-ruby-related) things to do in Portland, do let me know!

• You can specify the user you want to use to login to your gateway server like so: set :gateway, 'deploy@deploy.example.com'. This logs in to your gateway server as the “deploy” user.
• You can specify an alternate SSH port for both your gateway and your deployment servers. E.g. setting ssh_options[:port] = 11111 will make Capistrano SSH to your gateway server with on port 11111. For your actual application (and web and database) servers, you can specify the SSH port like so:

  set :gateway, 'deploy@deploy.example.com'
  role :app, '192.168.1.113:22222'
  role :web, '192.168.1.113:22222'
  role :db,  '192.168.1.113:22222', :primary => true

• If you’re using public key authentication, you should put the public keys of your users (those who be deploying your app) on the gateway server and on the actual servers. I thought Capistrano would use the key of the “deploy” user but nope.

change_table for ActiveRecord migrations

Thanks to Jeff Dean, who also blogged about the new change_table feature in ActiveRecord migrations, you can now change a table with a block like so:

change_table :videos do |t|
  t.add_timestamps
  t.add_belongs_to :goat
  t.add_string :name, :email, :limit => 20
  t.remove_column :name, :email # takes multiple arguments
  t.rename :new_name
  t.string :new_string_column # executes against the renamed table name
end

Some key things to note:

• add_XXX would add a new column for you, e.g. add_string would add a new string field.
• Of course, add_timestamps would add the magic created_at and updated_at datetime fields.
• remove_column now takes multiple arguments.
• rename would rename the table.

Very nice, DRY enhancement, props to Jeff Dean once again.

Related changeset: http://github.com/rails/rails/commit/96980bd561d79824b6cb6efbcbecdcbf8785d452

ActiveRecord::Base.create takes a block like ActiveRecord::Base.new

Yup now you can also create ActiveRecord objects with a block argument just like you could for ActiveRecord::Base.new:

@person = Person.create(params[:person]) do |p|
  p.name = 'Konata Izumi'
  p.age = 17
end

Credit goes to Adam Meehan for this patch.

Related changeset: http://github.com/rails/rails/commit/dd120ede53eaf71dee76894998a81626b7a689fc

Bugfix: change_column should be able to use :null => true on a field that
formerly had false

You can now use change_column in your migrations to alter a column as nullable if it was previously NOT NULL.

This bugfix is courtesy of Nate Wiger.

Related changeset: http://github.com/rails/rails/commit/10ef65a3b054270ed3d458ec8eb7c2b9a3e638f7

As always, let me know of any suggestions or how I can improve the Living on the Edge (of Rails) series.

Not much interesting to report this week – there were mostly a bunch of bugfixes and Ruby 1.8.7-compatibility commits.

Introduce ActiveResource::Base.timeout and rescuing from Timeout::Error in ActiveResource::Connection

These are 2 changes that I’d talked about earlier this week so I won’t repeat myself – take a read through ActiveResource timeouts and why it matters.

Smart integer datatype for the MySQL adapter in migrations

The MySQL adapter in Rails now maps the integer column type in your migrations to either smallint, int, or bigint depending on the :limit option.

This means that a migration like this:

def self.up
  create_table :searches do |t|
    t.integer :foo, :limit => 2
  end

will create your foo column as a smallint(2) MySQL datatype (instead of int(2) before). (More information MySQL numeric datatypes.)

Credit goes to DHH for this patch.

Related changeset: http://github.com/rails/rails/commit/a37546517dad9f6d9a7de6e1dba4d960909d71e8

As always, let me know of any suggestions or how I can improve the Living on the Edge (of Rails) series.

So what happens when the API you’re accessing via ActiveResource or Net::HTTP (or whatever, really, so long as there’s a network socket involved!) becomes unresponsive?

Unfettered outbound remote connections can kill your server

ActiveResource (or Net::HTTP or whatever you’re using) would block while waiting for the API to return. What did we learn about blocking IO in Operating Systems 101? That your process or thread gets stuck waiting for a response that’s what. So now your Mongrel/Thin/Ebb/X web server process basically stuck waiting for a response from an API that might return a response in 30 seconds, or maybe it’ll never return at all. It won’t be long before all your web server processes get blocked and its time to “kill dash nine” (kill -9) some processes and bring out the 500 error page. Yes, your server has been incapacitated and your website is now basically offline.

Timeouts and you

If you’re using Net::HTTP you can easily safeguard yourself against errors like this by setting a timeout on the socket connection. Like so:

def fetch_something_from_some_api(uri)
  http = Net::HTTP.new(uri.host, uri.port)
  http.read_timeout = timeout

  response = http.start { http.request(Net::HTTP::Get.new("#{uri.path}?#{uri.query}")) }
  response.is_a?(Net::HTTPSuccess) ? do_something_with(response.body) : nil
rescue Timeout::Error
  logger.warn("Timeout accessing #{uri}: #{$!}")
  nil
rescue
  logger.warn("Error accessing #{uri}: #{$!}")
  nil
end

Take note that you really do need to explicitly rescue from the Timeout::Error (or Interrupt) since it’s a child of the Interrupt class and not a StandardError.

Any good client library should also allow you to specify a timeout on the socket connection so read the API documentation.

So what’s this about ActiveResource?

So back to ActiveResource: Michael Koziarski was kind enough to commit my 2 patches (this and this) to ActiveResource so now on edge Rails, you can do this:

class Person < ActiveResource::Base
  self.site = 'http://api.people.com:3000/'
  self.timeout = 5
end

This sets the timeout to 5 seconds on the underlying Net::HTTP instance that ActiveResource uses. The default timeout (to be exact, the read_timeout) for Net::HTTP is 60 seconds on most Ruby implementations (that includes MRI). That’s far too long if your ActiveResource call is in a public-facing controller!

If you are using ActiveResource anywhere and haven’t safeguarded your application with a timeout, I think it’s a good idea to fix it by using edge Rails or at least applying the patch!

The 2nd ActiveResource patch introduces the ActiveResource::TimeoutError exception that you should rescue from whenever you make an ActiveResource call. When this happens, it’s up to your application to decide what to do (like show a placating we’re sorry message). At least your application is still able to do something!

This week’s report covers changes from 14 Apr 2008 to 20 Apr 2008 (the day the corresponding Rails Envy podcast was recorded).

Conditional caches_page

The caches_page now takes an :if option for specifying when a page can actually be cached via a Proc. You can now do this, for example:

caches_page :index, :if => Proc.new { |c| !c.request.format.json? }

That will only cache your index page if the requested format is not JSON.

Credit goes to Paul Horsfall for this enhancement.

Related changeset: http://github.com/rails/rails/commit/14a40804a29a57ad05ca6bffbe1e5334089593a9

New ActionView::TestCase for testing view helpers

Remember how you can now use specialized TestCase classes for testing controllers and ActionMailer classes? Now you can do the same with your Rails view helpers with the new ActionView::TestCase class.

Here’s a quick example:

module PeopleHelper
  def title(text)
    content_tag(:h1, text)
  end

  def homepage_path
    people_path
  end
end

class PeopleHelperTest < ActionView::TestCase
def setup
  ActionController::Routing::Routes.draw do |map|
    map.people 'people', :controller => 'people', :action => 'index'
    map.connect ':controller/:action/:id'
  end
end

def test_title
  assert_equal "<h1>Ruby on Rails</h1>", title("Ruby on Rails")
end

def test_homepage_path
  assert_equal "/people", homepage_path
end

Credit goes to Josh Peek for this sweet little enhancement.

ActiveSupport::Cache’s mem_cache_store accepts options

Even though Memcache-client was added to ActiveSupport recently, it didn’t allow you to specify any configuration options beyond just the IP of the memcached server. Now you can pass along more configuration options like so:

config.action_controller.fragment_cache_store = :mem_cache_store, 'localhost', { :compression => true, :debug => true, :namespace => 'foo' }

This patch is courtesy of Jonathan Weiss.

Related changeset: http://github.com/rails/rails/commit/9e1d506a8cfedef2fdd605e4cbf4bf53651ad214

As always, let me know of any suggestions or how I can improve the Living on the Edge (of Rails) series.

This week’s report covers changes from 7 Apr 2008 to 13 Apr 2008 (the day the corresponding Rails Envy podcast was recorded).

A helpers proxy method for accessing helper methods from outside of views

A helpers method has been introduced to ActionController – you can now access your helpers like so:

ApplicationController.helpers.simple_format(text)

Credit goes to 19 year old Josh Peek, one of the more prolific Rails contributors (and most likely to join Pratik in Rails Core imo).

Related changeset: http://github.com/rails/rails/commit/917423d664038d6791738a73ad1446437dbb71df

json_escape for escaping HTML entities in JSON strings

A json_escape (aliased as j, similar to how html_escape is aliased as h) has been introduced by Rick Olson for escaping HTML entities in JSON strings. This is useful if you find yourself emitting JSON strings in HTML pages (e.g. for documenting a JSON API):

json_escape("is a > 0 & a < 10?")
# => is a \u003E 0 \u0026 a \u003C 10?

Of course, since json_escape is aliased as j, you can do this in your ERB templates:

<%=j @person.to_json %>

Related changeset: http://github.com/rails/rails/commit/0ff7a2d89fc95dcb0a32ed92aab7156b0778a7ea

Automatically parse posted JSON content for Mime::JSON requests

Rails will now accept POSTed JSON content! For example, you can now send a POST to “/posts” of your Post resource like this:

POST /posts
{"post": {"title": "Breaking News"}}

And your create action will automatically parse the POSTed JSON into the request params so that this code below just works:

def create
  @post = Post.create params[:post]
end

Credit goes to Rick Olson.

Related changeset: http://github.com/rails/rails/commit/4d594cffcfc93b37fad4e423ec8593299e50133c

schema_migrations table replaces the schema_info table, allowing for interleaved migrations

A new schema_migrations table for storing which migrations have been run has been introduced, and this replaces the existing schema_info table (which simply keeps track of the last applied schema version). This change makes it possible to add migrations (for example, after you’ve merged from someone’s branch) – when you migrate your database via rake db:migrate, those never-applied “interleaved” migrations will be run. Similarly, when migrating down schema versions, never-applied “interleaved” will be skipped.

See http://dev.rubyonrails.org/ticket/11493 for more information.

This useful patch is the brainchild of Jordi Bunster (WWR profile). I’m sure many Rails developers who branch extensively will thank Jordi for this excellent patch!

Related changeset: http://github.com/rails/rails/commit/8a5a9dcbf64843f064b6e8a0b9c6eea8f0b8536e

gems:unpack:dependencies Rake task

Remember how you can now run the gems:unpack Rake task to unpack a gem into your vendor/gems/ directory (this was mentioned in an earlier Living on the Edge)?

David Dollar (Github profile) has firmed up that patch quite a bit by adding the gems:unpack:dependencies Rake task that unpacks the dependencies of the gems as well. So running:

gems:unpack:dependencies GEM=activecouch

would unpack the full Rubygem dependency tree of gems that the activecouch gem depends upon.

Related changeset: http://github.com/rails/rails/commit/4364c361b599f99bc2345ce4eb2d145b07ed8a0f

As always, let me know of any suggestions or how I can improve the Living on the Edge (of Rails) series! Now go out there and start forking Rails!

From this week onwards, I’ll be following Pratik’s suggestion to post about changes as they happen instead of after an entire week so expect a slight change in the format of Living on the edge for next week!

This week’s report covers changes from 31 Mar 2008 to 6 Apr 2008 (the day the corresponding Rails Envy podcast was recorded).

Rails.env, Rails.logger, Rails.cache, Rails.root

This has been a long time coming: You can now use Rails.env instead of RAILS_ENV, Rails.root instead of RAILS_ROOT, Rails.logger instead of RAILS_DEFAULT_LOGGER, and Rails.cache instead of RAILS_CACHE. Not having to use constants is nice because it always felt a bit dirty to have so many hard-coded constants in the Rails namespace.

Credit goes to Pratik Naik, the newest Rails core team member for this cleanup.

Related changeset: http://dev.rubyonrails.org/changeset/9180

Render :partial now works with a collection of heterogeneous elements

You can now use render :partial to render a collection of different elements and Rails will figure out which partial template to use. For example:

render :partial => [ monkey, donkey, dramatic_chipmunk ]

will render the monkey with the ‘monkeys/_monkey.html.erb’ partial, donkey with the ‘donkeys/_donkey.html.erb’ partial, and last but definitely not lest, dramatic_gopher with the ‘dramatic_chipmunks/_dramatic_chipmunk.html.erb’ partial

This is especially useful if when using STI, where your ActiveRecord model would return objects of different types. The collection [ monkey, donkey, dramatic_chipmunk ] could very well be something returned from your Animal model that has subclasses of Monkey, Donkey and DramaticChipmunk via STI.

Credit: Zach Dennis of ar-extensions fame.

Related changeset: http://dev.rubyonrails.org/changeset/9177

ActiveModel work revived

It seems like work on ActiveModel (think unified ActiveRecord and ActiveResource behaviors) has been revived, if the latest commits (http://dev.rubyonrails.org/changeset/9171 and http://dev.rubyonrails.org/changeset/9173) by David (DHH) is anything to go by.

Bugfix: Assigning an invalid has_one association now causes #save to fail on parent

You could do this before:

firm = Firm.find(:first)
firm.account = Account.new # Associate INVALID account
firm.save # This doesn't fail

Now that’s fixed thanks to Pratik Naik.

Related changeset: http://dev.rubyonrails.org/changeset/9232

As usual, any feedback is respectfully appreciated!

There’re lots of big exciting changes this week on edge. Smells like 2.1 soon!

has_finder gem merged into Rails

Ryan Daigle has the scoop on the new has_finder-like functionality in Rails so head on over (I won’t repeat it here in the interests of DRY).

Credit goes to Nick Kallen for coming up with the has_finder gem.

Related changeset: http://dev.rubyonrails.org/changeset/9084

ActiveRecord: Unsaved attribute changes are now tracked

You can now ask an ActiveRecord model whether its attributes have been changed (and is unsaved) using the {attr_name}_changed? (magic) method. The {attr_name}_was method will return the original value of the attribute, and the {attr_name}_change method will return an array with 2 members, the 1st being the original value, the 2nd being the changed (and unsaved) value.

# Change person's name.
person.name = 'Jason Seifer'
person.changed?       # => true
person.name_changed?  # => true
person.name_was       # => 'jseifer'
person.name_change    # => ['jseifer', 'Jason Seifer']
person.name = 'Ceiling Cat'
person.name_change    # => ['jseifer', 'Ceiling Cat']

Credit goes to Rails core team member Jeremy Kemper (bitsweat) for this patch (which originated from Jeremy’s very own Dirty plugin).

Related changeset: http://dev.rubyonrails.org/changeset/9127

ActiveRecord#Base.all/first/last

Now you can do:

Post.all.each { |post| # something }
Post.first
Post.last

Kinda like how some other ORMs do (like DataMapper).

Credit: thechrisoshow and again, Nick Kallen for has_finder.

Related changeset: http://dev.rubyonrails.org/changeset/9085

Timestamped Migrations

This is more useful than it sounds: migrations are now timestamped instead of using incremental numbers in your db/migrate folder. This eliminates the problem of migrations having the same version number when working on a multi-developer Rails app.

Two new Rake tasks, rake db:migrate:up/down, have been added to allow running of the up and down methods of individual migrations.

Credit goes to John Barnette, the guy who gave you foxy fixtures.

Related changeset: http://dev.rubyonrails.org/changeset/9122

New config.gem option for specifying which gems are required by the application + rake tasks for installing and freezing gems

Specify which gems are required by your Rails app in your Rails environment.rb! “Vendor everything” supported right in Rails :). An example:

Rails::Initializer.run do |config|
  config.gems 'chronic'
  config.gems "hpricot", :version => '0.6', :source => "http://code.whytheluckystiff.net"
  config.gems "aws-s3", :lib => "aws/s3"
end

There are also new Rake tasks:

# List required gems.
rake gems 

# Install all required gems:
rake gems:install 

# Unpack specified gem to vendor/gems/gem_name-x.x.x
rake gems:unpack GEM=chronic

Credit goes to the prolific Rick Olson for this gem of a patch.

Related changeset: http://dev.rubyonrails.org/changeset/9140

ActiveResource #clone

You can now clone an existing resource:

gregg = Person.find(1)
borg = gregg.clone

This doesn’t clone child ActiveResource members though, just the straight up attributes of resource.

Contribors: Ryan Daigle and thechrisoshow.

Related changeset: http://dev.rubyonrails.org/changeset/9121

Big documentation patch

A big doc patch consisting of all the efforts going on in the doc-rails repository on Github has been committed. Check out Pratik’s post for more info on what doc-rails is. Though with Rails moving to Git soon, doc-rails may no longer be necessary!

Related changeset: http://dev.rubyonrails.org/changeset/9093