Unix Signals for Live Debugging

It's unit tested, the integration and regressions tests are all green, you even added a set of performance benchmarks, and yet after a couple of hours of production use the process is falling over - we've all been there before. Good instrumentation in these situations is worth its weight in gold. If you're lucky, you may be able to use DTrace, if you're adventurous you may try to attach with GDB, but what if you build this instrumentation into your app right from the start?

System signals for easy debugging

Any UNIX process can respond to a collection of system signals, and what's even better: we can safely define a subset (USR1, and USR2) to invoke arbitrary logic within our process. For example, let's create a worker process which on receipt of a USR1 signal will toggle debug mode on demand:

> debug-mode.rb

require 'rubygems'
require 'log4r'
 
# initialize the logger
@log = Log4r::Logger.new 'log'
@log.outputters = Log4r::StdoutOutputter.new 'console'
@log.level = Log4r::INFO
 
worker = Thread.new do
  while (true) do
    @log.info 'Hello!'
    @log.debug 'Debug!'
    sleep(1)
  end
end
 
# put worker into debug mode via USR1 signal
trap("USR1") {
 @log.level = @log.level == Log4r::INFO ? Log4r::DEBUG : Log4r::INFO
}
 
# cleanly shutdown the thread on Ctrl-C / kill signal
trap("INT") { worker.terminate }
 
# run the worker
worker.join
 

debug-mode.rb (Ruby file)

Downloads: 0 File Size: 0.5 KB

In the example above Log4r provides us with a convenient logging hierarchy: DEBUG < INFO < WARN < ERROR < FATAL. By sending our process a USR1 signal (kill -s USR1 pid), we toggle between the INFO and DEBUG levels, allowing ourselves the luxury of performing live debugging without incurring the cost of redundantly logging debug information when we don't need it. Now you have the tools to perform that open-heart surgery.

INFO log: Hello! < process is started
INFO log: Hello!
INFO log: Hello! < process receives USR1
DEBUG log: Debug!
INFO log: Hello!
DEBUG log: Debug! < process receives USR1
INFO log: Hello!
INFO log: Hello!

For bonus points, check what signals your favorite UNIX processes respond to. For example, did you know that kill -s USR1 mongrel_pid will turn on debug mode on any Mongrel process? Make use of system signals, they're there for reason!

ActionScript: Literal XML

One feature of ActionScript I really like is the ability to use XML within the language. In ActionScript there's no need to use strings to represent XML, you can use XML inline just as you would any other literal (numbers, strings, etc).

Recently I was working on some dynamic code that needed to update based on an XML response. We were just getting started on the card, so instead of worrying about the service, how it was triggered, etc, we added a button to the interface that called the response parsing method and passed in an XML literal as an argument. The code is similar to what's shown below.

parseResponse(<user><firstName>Jay</firstName></user>);

var request:XML = <smart_list/>;
request.sort.order = "highest";
request.sort.field = "Average Position";
request.max_results = 10;
request.toXMLString(); // "<smart_list><sort><order>highest</order><field>Average Position</field></sort><max_results>10</max_results></smart_list>"

You See the Invisible Block?

require "rubygems";require "thin";require"markaby"; class Invisible
HTTP_METHODS =[:get,:post,:head,:put,:delete];attr_reader :request,
:response, :params; def initialize(&block); @actions =[]; @with=[];
@layouts={};@views={};@helpers=Module.new;@app=self; instance_eval(
&block) if block end; def action(method, route, &block); @actions<<
[method.to_s, build_route(@with*"/"+route),block] end;HTTP_METHODS.
each{|m|class_eval "def #{m}(r='/',&b); action('#{m}', r, &b) end"}
def with(route); @with.push(route);yield;@with.pop end; def render(
*args,&block);options=args.last.is_a?(Hash)?args.pop: {};@response.
status=options.delete(:status)||200;layout=@layouts[options.delete(
:layout)||:default];assigns={:request=>request,:response=>response,
:params=>params,:session=>session};content=args.last.is_a?(String)?
args.last : Markaby::Builder.new(assigns,@helpers, &(block||@views[
args.last] )).to_s ; content = Markaby::Builder.new( assigns.merge(
:content => content), @helpers, &layout).to_s if layout; @response.
headers.merge!(options);@response.body=content end;def layout(name=
:default, &block); @layouts[name]=block end; def view(name,&block);
@views[name]=block end; def helpers(&block);@helpers.instance_eval(
&block ) ; instance_eval(&block)  end;  def session;  @request.env[
"rack.session"]end; def use(middleware, *args);@app=middleware.new(
@app,*args) end; def run(*args);Thin::Server.start(@app, *args) end
def call(env); @request = Rack::Request.new(env); @response =Rack::
Response.new; @params = @request.params; if action = recognize(env[
"PATH_INFO"], @params["_method"] ||env["REQUEST_METHOD"]); @params.
merge!(@path_params);action.last.call;@response.finish; else; [404,
{}, "Not found"]; end; end; def self.run(*args,&block);new(&block).
run(*args) end; def self.app;@app||=self.new end;def self.call(env)
@app.call(env) end; private; def build_route(route);pattern= route.
split("/").inject('\/*') { |r, s| r << (s[0] == ?: ? '(\w+)' : s) +
'\/*' } + '\/*';[/^#{pattern}$/i,route.scan(/\:(\w+)/).flatten] end
def recognize(url, method); method =method.to_s.downcase; @actions.
detect do |m,(pattern,keys),_| method==m&&@path_params=match_route(
pattern,keys,url)end;end;def match_route(pattern,keys,url);matches,
params=(url.match(pattern)||return)[1..-1],{};keys.each_with_index{
|key,i| params[key]=matches[i]};params;end;end; def method_missing(
method, *args,  &block);  ; if Invisible.app .respond_to?(method) ;
Invisible.app. send( method, *args, &block);  else; super; end; end

No!

beauty is fleeting (or why rails-doc isn’t the answer but something else might be)

So my last post, for whatever reason, spawned a flurry of posts pointing to rails-doc, a project by a team from Nodeta, claiming that it solved a number of Rails documentation problems. It’s a very nice looking project with a sexy theme (their blog design is especially attractive), but I’m sort of having a problem seeing how this solves any sort of problem that hasn’t been “solved” before.

For those of you too new to Rails to remember, there was (and apparently still is a project) named Rails Manual that does the exact same thing in a less attractive shell.  It’s based on a project named Rannotate, which creates a Rails app from your Ruby project’s documentation and enables adding notes to it.  It garnered a little attention when it first came out, but eventually went the way of the buffalo.

So now we have rails-doc.  Like I said, it looks good, but it strikes me as the exact same thing.  It’s basically the RDoc’s with notes, which solves a piece of the problem, but it’s not anywhere near a total fix for the poor documentation situation (even though I think some people are on the right track!).  If I’d known that all we needed was a good looking RDoc app, I could’ve fixed the problem a while ago.

That’s a screenshot of the design that my Google Summer of Code student (Ian Ownbey) and I are currently working on applying to his project Docbox and my derivative project Docdock (which will be on my Github very soon). 

Docbox is like Rannotate and friends (it lets you add notes, browse, search, etc.) except it also lets users actually edit the documentation in their browser.  It will then take their edits and generate a git commit on its own branch on the backend that the developers can cherry pick back into the mainline documentation.  You want to talk about user contribution?  There it is.  I’m waiting for my student to deploy to a slice and I’ll link that demo site here.  The plan is to let you edit the docs on a sample app and see your changes get pushed straight to a Github project so you can see it happen in near real-time.

My project is slightly less glamorous.  Docdock is essentially a client facing application based on Docbox.  Projects like Rails or a company with a closed source Ruby product could use Docdock to have an API site that users can visit, add notes to, and get involved with that looks good but without allowing everyone to edit it.  Larger or proprietary projects probably don’t want their official doc site to be totally editable.  The good thing about Docdock is that it can actually hook into the same database as Docbox, so you can have an instance of Docbox running on the backend for your team and an instance of Docdock running on the front end for your users.  This will probably just create a separate connection to keep everything separate except for the documentation objects, but I haven’t gotten quite that far yet.

So, there you go.  Two documentation tools geared towards user contribution.  Oh, and did I mention they’re both totally open source and applicable to any Ruby project, not just Rails?  I didn’t bring them up before because I didn’t know how interested people would be, but if people get excited about a resurrected Rannotate with dcov and search thrown in, then surely people will find these tools useful.

RubyFringe == Awesome

Nick Sieger though us about Jazz, Giles Bowkett got a standing ovation, Zed Shaw sang “Matz can’t patch” and “Don’t fuck Chad’s community”, Geoffrey Grosenbach was wearing a kilt, Hampton Catlin presented Haml for Javascript, Damien Katz made me cry and Tom Preston-Werner is my new hero.

Better reviews

• http://globalnerdy.com/2008/07/20/rubyfringe-day-1-notes-part-1/
• http://globalnerdy.com/2008/07/20/rubyfringe-day-1-notes-part-2/
• http://globalnerdy.com/2008/07/21/rubyfringe-day-2-notes-part-1/
• http://www.seanr.ca/tech/?p=27
• http://www.seanr.ca/tech/?p=30

Google Introduces Binary Encoding Format: Protocol Buffers

Google caused a stir by releasing Protocol Buffers, a binary serialization format. We take a look at what exactly Protocol Buffers are and what alternatives are available in ASN.1 or Facebook's Thrift. By Werner Schuster

Databases Roundup: Data Sharding for ActiveRecord and Faster Postgres IO

In this databases roundup we take a look at DataFabric, FiveRun's recently open sourced data sharding plug-in for ActiveRecord. Also: a look at speeding up Postgres data access using the asynchronous client API and Ruby 1.9's Fibers. By Mirko Stocker

hasiphone.com now with US map

Thanks to the Degrafa library I was able to add a “US Map of iPhone 3G” Availability in an hour to the hasiphone.com application.

Also I automated the extraction part of the data and check every hour if new data is there. I was assuming that the data changes only once a day and therefore all the delta (the + and – next to the availability) are based on previous day. This morning there were only four stores with iPhones, and hour ago 76 and now 78. So it seems that the data is updated more frequently or I have a bug in my extraction routing. Whatever the situation I am leaving on vacations for the next two weeks and won’t take my notebook with me, so hopefully the data is correct. My good friend Sol will keep an eye on the extraction process to see that we get some daily data. Thanks Sol, ya da man.

Enjoy! Daniel.

is cool

Practical Prototype and script.aculo.us book hot off the presses

Prototype Core team member Andrew DuPont’s new book Practical Prototype and script.aculo.us is now available, and it’s a super no-nonsense guide to getting up to speed with the libraries, fast.

Andrew, being a UI developer by heart, doesn’t mess around and gives you hands-on examples for just about everything you can do with the “fraternal twins” Prototype and script.aculo.us.

You’ll learn how to really use all those fancy Prototype collection helpers (like each, detect, select, reject, partition, etc.), master the cool new custom events system, and seriously mess with the DOM; and how’ll see how Prototype can help you with everyday programming tasks with its extensions to functional programming and OOP. Plus of course how to make the most of Ajax and JSON. Last but not least, visual effects are explained, and also how they work by taking advantage of the DOM and how web browsers render websites.

The very interesting closing chapter shows you why things are as they are in Prototype, and will help you read the source code—and write JavaScript, Prototype-style.

Internet Explorer 6 on its way out (or not)?

Since attaining a peak of about 95% usage share during 2002 and 2003, Internet Explorer 6 (IE6) has been rapidly losing market share. As the end of 2008 approaches, significant online services, vendors and web frameworks are dropping support for IE6. Will this year be the end of IE6 and what does this signify for Web 2.0 developers? By Dionysios G. Synodinos