I tried to restart Rails application gracefully (apachectl graceful) with mod_fcgid, but I couldn't get a response on graceful restart.

The problems are:

• mod_fcgid sends SIGTERM to FastCGI processes on graceful restart, but Rails FastCGI processes exit as soon as it's received SIGTERM (Rails FastCGI processes stop gracefully on SIGUSR1, not SIGTERM).
• Apache child processes exit on SIGUSR1 with mod_fcgid, as soon as it's received a signal.

I created a patch to fix these problems, but I'm not sure....

I felt my application slow yesterday and profiled it. RJS is very useful, but it seems to be slow.

Thanks to Charlies's ruby-prof (it doesn't belongs to me any more and has fascinating call graph support), I found the bottleneck. It was Object#to_json.

The original code is here:

define_encoder String do |string|
  returning value = '"' do
    string.each_char do |char|
      value << case
      when char == "\010":  '\b'
      when char == "\f":    '\f'
      when char == "\n":    '\n'
      when char == "\r":    '\r'
      when char == "\t":    '\t'
      when char == '"':     '\"'
      when char == '\':    '\\'
      when char.length > 1: "\u#{'%04x' % char.unpack('U').first}"
      else;                 char
      end
    end
    value << '"'
  end
end

Ruby can't handle characters fast, so this code is very slow. You'd should use builtin methods such as String#gsub to handle multiple characters at once.

I put the following code into config/environment.rb, and it looks quite fast:)

class String
  JSON_ESCAPED = {
     "\010" =>  '\b',
     "\f" =>    '\f',
     "\n" =>    '\n',
     "\r" =>    '\r',
     "\t" =>    '\t',
     '"' =>     '\"',
     '\' =>    '\\'
  }

  def to_json
    return '"' + gsub(/[\010\f\n\r\t"\]/) { |s|
      JSON_ESCAPED[s]
    } + '"'
  end
end

Then I posted a patch to a related ticket.

If there is any reason to encode multibyte characters, more hacks are needed. I think the best way is to encode multiple multibyte characters at once using String#gsub and String#unpack, Array#pack.

PessimisticLocking provides row-level pessimistic locking using SELECT FOR UPDATE.

You can specify the new option :lock of ActiveRecord::Base.find() to lock rows:

Account.transaction do
  shugo = Account.find(:first, :conditions => "name = 'shugo'", :lock => true)
  yuko = Account.find(:first, :conditions => "name = 'yuko'", :lock => true)
  shugo.balance -= 100
  shugo.save
  yuko.balance += 100
  yuko.save
end

Or you can also use ActiveRecord::Base#lock() instead:

Account.transaction do
  accounts = Account.find(:all, :conditions => ...)
  account1 = accounts.detect { |account| ... }
  account2 = accounts.detect { |account| ... }
  account1.lock
  account2.lock
  account1.balance -= 100
  account1.save
  account2.balance += 100
  account2.save
end

The latter way may be better if you don't need lock all SELECTed rows.

Minero Aoki reported that Rails worked on YARV. It's cool.

The japanese translation of Agile Web Development with Rails will be published from Ohmsha at the latest in February 2006. This is not an official announcement, so please do not contact bookstores yet.

I'm reviewing it, and it's a very interesting job. Thanks, Dave Thomas and David Heinemeier Hansson!