Callbacks from model to request?

I’d like to ask if people have thoughts on clean ways of making
behaviour in the model depend on attributes of the request.

Things I’m thinking of:

  • per-user (currently handled by setting a thread-local
    variable in the controller)

  • created_by and updated_by fields. Googling around, the recommended
    way seems to be the same, set Thread.current[‘user’] = session[:user]
    in a before filter

  • updated_ip (i.e. logging request.ip when a model is saved). Ditto.

  • when I do a bulk update from a controller, I’d like all the
    updated_at timestamps to be exactly the same (when using millisecond-
    accurate timestamps), so as to allow the changes to be grouped in a
    query (“group by updated_at”). That means taking a snapshot of the
    current time, and using it in all the model updates for the duration
    of that request.

It seems to me that doing all this via Thread-local variables is a bit
icky. For one thing, you have to remember to erase them before each
new request. And if you take it to the extreme, you might be tempted
to do
Thread[‘session’] = session
Thread[‘request’] = request
etc, possibly burying things like access-control logic in the model.

I’d be interested to hear if anyone has implemented a cleaner way for
the model layer to make limited callbacks to the controller layer, and
how you designed it.

I think you’d want an object which exposes methods that are not made
public on the controller itself (because you don’t want them
accessible from the outside world). Thinking aloud:

class FooController < ApplicationController
class Callback
def initialize(ctrl)
@ctrl = ctrl
def time
@time ||=
def zone
@zone ||= @ctrl.instance_eval { session[:tz] }
def ip
@ip ||= @ctrl.instance_eval { request.ip }

before do
Thread.current[‘callback’] =

Any better ideas?