Jobs: We’ve been having record quarter after record quarter, so we’re very pleased with how the company’s doing. And, uh, you know, Wall Street, I’ve never been able to figure out Wall Street. But someone once told me manage the top line, which is, your strategy, your talented people, and your execution, and the bottom line will take care of itself. And I’ve always found that to be the case. So, we’re turning in record quarter after record quarter, and Wall Street eventually comes out in the right place.

Without json_reformat

$ curl http://github.com/api/v2/json/user/show/powdahound
{"user":{"gravatar_id":"d5894734b9f67c07b276319fdc2e5d88","company":"HipChat",
"name":"Garret Heaton","created_at":"2009/04/04 08:36:09 -0700",
"location":"Sunnyvale, CA","public_repo_count":18,"public_gist_count":67,
"blog":"http://powdahound.com","following_count":8,"id":70472,"type":"User",
"permission":null,"followers_count":7,"login":"powdahound",
"email":"powdahound@gmail.com"}}

With json_reformat

$ curl -s http://github.com/api/v2/json/user/show/powdahound | json_reformat
{
  "user": {
    "gravatar_id": "d5894734b9f67c07b276319fdc2e5d88",
    "company": "HipChat",
    "name": "Garret Heaton",
    "created_at": "2009/04/04 08:36:09 -0700",
    "location": "Sunnyvale, CA",
    "public_repo_count": 18,
    "public_gist_count": 67,
    "blog": "http://powdahound.com",
    "following_count": 8,
    "id": 70472,
    "type": "User",
    "permission": null,
    "followers_count": 7,
    "login": "powdahound",
    "email": "powdahound@gmail.com"
  }
}

So much nicer!

It will even tell you if there are syntax syntax errors (as will json_verify).

The setup was very simple:

1. Buy the domain (name.com is so much nicer than GoDaddy by the way).
2. Point domain’s nameservers at my slicehost account.
3. Add a new DNS domain in slicehost and add a single CNAME record with a name of ‘www’ and data of ‘s3-website-us-east-1.amazonaws.com.’
4. Install the latest Cyberduck (Mac). Windows users can use one of the tools here.
5. Create a new S3 bucket called ‘www.ec2instances.info’ and configure it for static site hosting.
6. Upload all my files and change their permissions to make them readable by everyone.
7. Done!

Updating the site is easy – just select the file in Cyberduck and click the ‘Edit’ icon in the toolbar (or hit ⌘K) and it will automatically upload the file whenever you save. If I needed a real deploy system it’d be pretty easy to whip up something with Fabric and Boto.

Overall it seems like a great way to host a static site on the cheap (~$1.50/year for this). The only real downside is that you can’t have your root domain hit the bucket because a CNAME must be used. This means that ec2instances.info does not resolve properly. More details here.

Note: I tried to use Amazon’s new Route 53 DNS service instead of my slicehost account but the configuration is still a bit more involved than I’d like. Hopefully they’ll add it to the AWS web console soon.

From the README:

Hooks can be very powerful and useful. Some common hooks include:

- Spell check the commit message.
- Check that the code builds.
- Verify that any new files contain a copyright with the current year in it.

Hooks can be very project specific such as:

- Verify that the project still builds
- Verify that autotests matching the modified files still pass with no errors.
- Pre-populate the commit message with the ‘standard’ format.
- Verify that any new code follows the ‘standard’ coding style.

or very specific to one person such as:

- Don’t allow a push to a remote repository after 1am in case I break something and will be asleep.
- Don’t let me commit between 9-5 for projects in ~/personal/ as I shouldn’t be working on them during work hours.

I wrote some hooks for checking PHP syntax and checking Python files using PEP-8 and PyFlakes.

Hopefully they’ll integrate this functionality into the git core at some point.

Here’s the solution I came up with:

desc "Do a rolling restart of <service>"
deploy.task :restart do
  hosts = self.roles[:server].to_ary # change :server to your role
  num_hosts = hosts.size
  hosts.each_with_index do |host, i|
    puts "Restarting <service> on #{host} (#{i+1} of #{num_hosts})"
    sudo "/etc/init.d/<sevice> restart", :hosts => host
    if i < num_hosts-1
      puts "Waiting 3s before next host."
      sleep(3)
    end
  end
end

Here are some helpful guides for getting started:

• Working with SEC- the Simple Event Correlator
• Monitoring with Simple Event Correlator
• sec man page

At HipChat we use a config like the following to to monitor Apache’s error_log for PHP errors and send us emails:

# Capture error lines and store them in apache-php-errors
type=Single
ptype=RegExp
pattern=^\[.+\] \[error\] \[client .+\] PHP .+$
desc=PHP error or warning
action=add apache-php-errors $0
 
# Report errors every minute if apache-php-errors is set
type=Calendar
time=* * * * *
desc=Mail web errors
context=apache-php-errors
action=report apache-php-errors /usr/bin/mail -s "PHP errors" alerts@company.com; delete apache-php-errors;

Assuming you put this config in /etc/sec/apache.conf you’d run:

$ sec --conf=/etc/sec/apache.conf --input /var/log/apache2/error_log

Try writing a few of your own rules (the –debug flag is very helpful) or the examples in the tutorials above. SEC is incredibly powerful and can make complex monitoring tasks very simple.

Level 1 Productions – Eye Trip

Matchstick Productions – The Way I See It

Poor Boyz Productions – Revolver.

Teton Gravity Research – Light the Wick

Warren Miller – Session #61

Shlomo Swidler has a great article comparing different DNS configurations as well as some sample code for dynamically updating hosts files. However, if you’re already using Chef you can achieve the same thing with a very simple cookbook.

First, create a new cookbook:

$ cd chef-repo/
$ rake new_cookbook COOKBOOK=hosts CB_PREFIX=site-

Place the following in site-cookbooks/hosts/recipes/default.rb:

# Find all nodes, sorting by Chef ID so their
# order doesn't change between runs.
hosts = search(:node, "*:*", "X_CHEF_id_CHEF_X asc")
 
template "/etc/hosts" do
  source "hosts.erb"
  owner "root"
  group "root"
  mode 0644
  variables(
    :hosts => hosts,
    :fqdn => node[:fqdn],
    :hostname => node[:hostname]
  )
end

Then create the template, site-cookbooks/hosts/templates/default/hosts.erb:

127.0.0.1   localhost
 
<% @hosts.keys.sort.each do |fqdn| %>
<%= @hosts[fqdn][:ipaddress] %> <%= fqdn %> <%= @hosts[fqdn][:hostname] %>
<% end %>
 
# The following lines are desirable for IPv6 capable hosts
::1 ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters
ff02::3 ip6-allhosts

Add the recipe to your node’s run_list and run chef-client and your /etc/hosts should contain all the Chef nodes on your network. Note that one downside to this approach is that updates will be slow (since chef-client only runs every 30 minutes by default).

Now what if you wanted to point at a specific service, like having chef.example.com point at your Chef master? Just search for it in your recipe (and add it to the variables list):

chef_server = search(:node, 'run_list:recipe\[chef\:\:server\]')

And add a line to the template:

# Chef master server
<%= @chef_server[:ipaddress] %> chef.example.com

Sure beats setting up a DNS server!

If you haven’t heard of Redis before, it’s a key-value store similar to memcached with support for more complex data types like lists, sets, and hashes. collectd is a stats collection daemon which recently added support for plugins written in Python. This is great because there’s no way I’d write a plugin in C! Anyway, you can use this plugin to collect data about your Redis server like number of active connections, database size, commands processed per second, and memory usage. You can then use a tool like drraw to generate nice graphs:

More info and installation instructions on the GitHub page.