panmind-usage-tracker 0.4.0

data/README.md

@@ -0,0 +1,65 @@
+Panmind Usage Tracker
+---------------------
+
+What is it?
+===========
+
+ 1. A `Rack::Middleware` that sends selected parts of the request environment to an UDP socket
+ 2. An `EventMachine` daemon that opens an UDP socket and sends out received data to CouchDB
+ 3. A set of CouchDB map-reduce views, for analysis
+
+
+Does it work?
+=============
+
+Yes, but the release is still incomplete, because currently tests are too
+tied to Panmind logic.
+
+If you can help in complete the test suite, it is much appreciated :-).
+
+Deploying
+=========
+
+ * Add the usage_tracker gem to your Gemfile and require the middleware
+
+   gem 'usage_tracker', :require => 'usage_tracker/middleware'
+
+ * Add the Middleware to your application:
+
+    Your::Application.config.middleware.use UsageTracker::Middleware
+
+ * The daemon can be started manually with the following command, inside a Rails.root:
+
+     $ usage_tracker [environment]
+
+   `environment` is optional and will default to "development" if no command line
+   option nor the RAILS_ENV environment variable are set.
+
+   or can be put under Upstart using the provided configuration file located in
+   `config/usage_tracker_upstart.conf`. Check it out and modify it to suit your needs.
+
+   The daemon logs to `log/usage_tracker.log` and rotates its logs when receives
+   the USR1 signal.
+
+ * The daemon writes its pid into tmp/pids/usage_tracker.pid
+
+ * The daemon connects to a Couch database named `usage_tracker` running on `localhost`,
+   default port `5984/TCP`, and listens on `localhost`, port `5985/UDP` by default.
+   You can change these settings via a `config/usage_tracker.yml` file. See the example
+   in the `config` directory of the gem distribution.
+
+ * The CouchDB instance must be running, the database is created (and updated)
+   if necessary.
+
+ * If the daemon cannot start, e.g. because of unavailable database or listening
+   address, it will print a diagnostig message to STDERR, log to usage_tracker.log
+   and exit with status of 1.
+
+ * The daemon exits gracefully if it receives the INT or the TERM signals.
+
+Testing
+=======
+
+The current test suite, brutally extracted from Panmind codebase, is in the
+`middleware_test.rb` file at the root of the Gem distribution. It is of no
+use except Panmind, but it's a start for writing new ones. Please help! :-)

data/Rakefile

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+#
+require 'rake'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name        = 'panmind-usage-tracker'
+    gemspec.summary     = 'Write your application request logs in CouchDB'
+    gemspec.description = 'This software implements a Rails 3 Middleware and ' \
+                          'an EventMachine reactor to store into CouchDB the ' \
+                          'results of HTTP request processing'
+
+    gemspec.authors     = ['Marcello Barnaba', 'Christian Wörner']
+    gemspec.homepage    = 'http://github.com/Panmind/usage_tracker'
+    gemspec.email       = 'vjt@openssl.it'
+
+    gemspec.add_dependency('rails', '~> 3.0')
+    gemspec.add_dependency('eventmachine')
+    gemspec.add_dependency('couchrest')
+  end
+rescue LoadError
+  puts 'Jeweler not available. Install it with: gem install jeweler'
+end
+
+desc 'Generate the rdoc'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_files.add %w( README.md lib/**/*.rb )
+
+  rdoc.main  = 'README.md'
+  rdoc.title = 'Rails Application Usage Tracker on CouchDB'
+end
+
+desc 'Will someone help write tests?'
+task :default do
+  puts
+  puts 'Can you help in writing tests? Please do :-)'
+  puts
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.4.0

data/bin/usage_tracker

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'usage_tracker/reactor'

data/config/usage_tracker.yml.sample

@@ -0,0 +1,13 @@
+defaults: &defaults
+  couchdb: "http://admin:suxsux@127.0.0.1:5984/usage_tracker"
+  listen:  "127.0.0.1:5985"
+
+development:
+  <<: *defaults
+
+production:
+  <<: *defaults
+
+test:
+  <<: *defaults
+  couchdb: "http://admin:suxsux@127.0.0.1:5984/usage_tracker_test"

data/config/usage_tracker_upstart.conf

@@ -0,0 +1,15 @@
+description "Panmind Usage Tracker Daemon"
+author "Marcello Barnaba <marcello.barnaba@gmail.com>"
+version "1.1"
+
+start on runlevel [2345]
+stop on shutdown
+respawn
+
+# The following line assumes that you're using RVM, that's why
+# bash is invoked: to load rvm setup scripts.
+#
+# You should change the user under your webapp runs (panmind
+# in this example) and the Rails.root (panmind/deploy).
+#
+exec sudo -i -H -u panmind bash -c 'echo; cd panmind/deploy; exec usage_tracker'

data/config/views.yml

@@ -0,0 +1,139 @@
+<%
+  # Currently defined path prefixes, in JS Regexp format
+  #
+  _AREAS_RE = '\/(' << %w( inbox res projects users account publish search ).join('|') << ')'
+
+  # Expands to JS code that defines the "area" variable by
+  # executing the _AREAS_RE regexp onto the "path_info"
+  # property of the "doc" object.
+  #
+  _GET_AREA = %(
+    var match = doc.env.path_info.match (/#{_AREAS_RE}/);
+    var area  = match ? match[1] : 'other';
+  ).gsub(/\s+/x, ' ').strip
+%>
+
+_id     : '_design/basic'
+language: 'javascript'
+version : '2010110401' # Format: YYYY MM DD VV
+views   :
+  by_timestamp:
+    map: |
+      function (doc) {
+        if (doc.env)
+          emit (doc._id, doc);
+      }
+
+  by_date:
+    map: |
+      function (doc) {
+        var date = new Date (parseFloat (doc._id) * 1000);
+        emit([date.getUTCFullYear (), date.getUTCMonth (), date.getUTCDate ()], 1);
+      }
+
+    reduce: |
+      function (keys, values) {
+        return sum (values);
+      }
+
+  by_user_and_timestamp:
+    map: |
+      function (doc) {                                        
+        if (doc.env)
+          emit ([doc.user_id, doc._id], doc);
+      }
+
+  res_count:
+    map: |
+      function (doc) {
+        if (doc.env && doc.env.path_info.indexOf ('res/') > 0)
+          emit (doc.env.path_info.split ('/')[2], 1);
+      }
+    reduce: |
+      function (keys, values, rereduce) {
+        return sum (values);
+      }
+
+  res_item_count:
+    map: |
+      function (doc) {
+        if (doc.env && doc.env.path_info.indexOf ('res/') > 0) {
+          var pieces = doc.env.path_info.split ('/');
+          if (pieces.length > 3)
+            emit ([pieces[2], pieces[3]], 1);
+        }
+      }
+    reduce: |
+      function (keys, values, rereduce) {
+         return sum (values);
+      }
+
+  user_res_count:
+    map: |
+      function (doc) {
+        if (doc.env && doc.env.path_info.indexOf ('res/') != -1)
+          emit ([doc.user_id, doc.env.path_info.split ('/')[2]], 1);
+      }
+    reduce: |
+      function (keys, values, rereduce) {
+        return sum (values);
+      }
+
+  user_area_count:
+    map: |
+      function (doc) {
+        if (doc.env) {
+          <%= _GET_AREA %>
+          emit ([doc.user_id, area], 1);
+        }
+      }
+    reduce: |
+      function (keys, values, rereduce) {
+        return sum (values);
+      }
+
+  area_count:
+    map: |
+      function (doc) {
+        if (doc.env) {
+          <%= _GET_AREA %>
+          emit (area, 1);
+        }
+      }
+    reduce: |
+      function (keys, values, rereduce) {
+        return sum (values);
+      }
+
+  average_duration_of_path:
+    map: |
+      function (doc) {
+        if (doc.duration)
+          emit (doc.env.path_info, doc.duration);
+      }
+    reduce: |
+      function (keys, values){
+        return Math.round (sum (values) / values.length);
+      }
+
+  average_duration_of_area:
+    map: |
+      function (doc) {
+        if (doc.duration) {
+          <%= _GET_AREA %>
+          emit (area, doc.duration)
+        }
+      }
+    reduce: |
+      function (keys, values){
+        return Math.round (sum (values) / values.length);
+      }
+
+  by_user_timestamp_area:
+    map: |
+      function (doc) {
+        if (doc.env) {
+          <%= _GET_AREA %>
+          emit ([doc.user_id, doc._id, area], doc);
+        }
+      }

data/lib/usage_tracker.rb

@@ -0,0 +1,116 @@
+require 'rubygems'
+require 'erb'
+require 'yaml'
+require 'pathname'
+require 'ostruct'
+require 'couchrest'
+require 'active_support/core_ext/object/blank'
+require 'usage_tracker/log'
+
+module UsageTracker
+  class << self
+    # Memoizes the current environment
+    def env
+      @env ||= ENV['RAILS_ENV'] || ARGV[0] || 'development'
+    end
+
+    @@defaults = {
+      'couchdb' => 'http://localhost:5984/usage_tracker',
+      'listen'  => '127.0.0.1:5985'
+    }
+
+    # Memoizes settings from the ./config/usage_tracker.yml file,
+    # relative from __FILE__ and searches for the "usage_tracker"
+    # configuration block. Raises RuntimeError if it cannot find
+    # the configuration.
+    #
+    def settings
+      @settings ||= begin
+        log "Loading #{env} environment"
+
+        rc_file  = Pathname.new('.').join('config', 'usage_tracker.yml')
+        settings = YAML.load(rc_file.read)[env] if rc_file.exist?
+
+        if settings.blank?
+          settings = @@defaults
+          log "#{env} configuration block not found in #{rc_file}, using defaults"
+        elsif settings.values_at(*%w(couchdb listen)).any?(&:blank?)
+          raise "Incomplete configuration: please set the 'couchdb' and 'listen' keys"
+        end
+
+        host, port = settings.delete('listen').split(':')
+
+        if [host, port].any? {|x| x.strip.empty?}
+          raise "Please specify where to listen as host:port"
+        end
+
+        settings['host'], settings['port'] = host, port.to_i
+
+        OpenStruct.new settings
+      end
+    end
+
+    def database
+      @database or raise "Not connected to the database"
+    end
+
+    # Connects to the configured CouchDB and memoizes the
+    # CouchRest::Database connection into an instance variable
+    # and calls +load_views!+
+    #
+    # Raises RuntimeError if the connection could not be established
+    #
+    def connect!
+      @database =
+        CouchRest.database!(settings.couchdb).tap do |db|
+          db.info
+          log "Connected to database #{settings.couchdb}"
+        end
+
+      load_views!
+    rescue Errno::ECONNREFUSED, RestClient::Exception => e
+      raise "Unable to connect to database #{settings.couchdb}: #{e.message}"
+    end
+
+    def write_pid!(pid = $$)
+      dir = Pathname.new('.').join('tmp', 'pids')
+      dir = Pathname.new(Dir.tmpdir) unless dir.directory?
+      dir.join('usage_tracker.pid').open('w+') {|f| f.write(pid)}
+    end
+
+    def log(message = nil)
+      @log ||= Log.new
+      message ? @log.info(message) : @log
+    end
+
+    def raise(message)
+      log.error message
+      Kernel.raise Error, message
+    end
+
+    private
+      # Loads CouchDB views from views.yml and verifies that
+      # they are loaded in the current instance, upgrading
+      # them if necessary.
+      def load_views!
+        new = YAML.load ERB.new(
+          Pathname.new(__FILE__).dirname.join('..', 'config', 'views.yml').read
+        ).result
+
+        id  = new['_id']
+        old = database.get id
+
+        if old['version'].to_i < new['version'].to_i
+          log "Upgrading Design Document #{id} to v#{new['version']}"
+          database.delete_doc old
+          database.save_doc new
+        end
+
+      rescue RestClient::ResourceNotFound
+        log "Creating Design Document #{id} v#{new['version']}"
+        database.save_doc new
+      end
+  end
+
+  class Error < StandardError; end
+end

data/lib/usage_tracker/context.rb

@@ -0,0 +1,27 @@
+require 'usage_tracker/log'
+
+module UsageTracker
+  module Context
+    @@key = 'usage_tracker.context'.freeze
+    mattr_reader :key
+
+    # Sets the env +Key+ variable with the provided +data+
+    #
+    def usage_tracker_context=(data)
+      unless request.env[key].blank?
+        unless Rails.env.test? && !caller.grep(/test\/functional/).blank?
+          UsageTracker.log 'WARNING: overwriting context data!'
+        end
+      end
+
+      request.env[key] = data
+    end
+
+    # Shorthand for self.usage_tracker_context = data
+    #
+    def usage_tracker_context(data)
+      self.usage_tracker_context = data
+    end
+
+  end
+end

data/lib/usage_tracker/log.rb

@@ -0,0 +1,45 @@
+require 'logger'
+
+module UsageTracker
+  class Log
+    attr_reader :path
+
+    [:debug, :info, :warn, :error, :fatal].each do |severity|
+      define_method(severity) {|*args| @logger.send(severity, *args)}
+    end
+
+    def initialize
+      open
+    end
+
+    def path
+      @path ||= if File.directory?('log')
+        Pathname.new('.').join('log', 'usage_tracker.log')
+      else
+        Pathname.new('usage_tracker.log')
+      end
+    end 
+
+    def open
+      @logger           = Logger.new(path.to_s)
+      @logger.formatter = Logger::Formatter.new
+      @logger.info 'Log opened'
+
+    rescue
+      raise Error, "Cannot open log file #{path}"
+    end
+
+    def close
+      return unless @logger
+
+      @logger.info 'Log closed'
+      @logger.close
+      @logger = nil
+    end
+
+    def rotate
+      close
+      open
+    end
+  end
+end

data/lib/usage_tracker/middleware.rb

@@ -0,0 +1,94 @@
+require 'timeout'
+require 'usage_tracker'
+require 'usage_tracker/context'
+require 'usage_tracker/railtie' if defined?(Rails)
+
+# This middleware extracts some data from the incoming request
+# and sends it to the reactor, that parses and stores it.
+#
+module UsageTracker
+  class Middleware
+    @@headers = [
+      "REMOTE_ADDR",
+      "REQUEST_METHOD",
+      "PATH_INFO",
+      "REQUEST_URI",
+      "SERVER_PROTOCOL",
+      #"HTTP_VERSION",
+      "HTTP_HOST",
+      "HTTP_USER_AGENT",
+      "HTTP_ACCEPT",
+      "HTTP_ACCEPT_LANGUAGE",
+      "HTTP_X_FORWARDED_FOR",
+      "HTTP_X_FORWARDED_PROTO",
+      #"HTTP_ACCEPT_LANGUAGE",
+      #"HTTP_ACCEPT_ENCODING",
+      #"HTTP_ACCEPT_CHARSET",
+      #"HTTP_KEEP_ALIVE",
+      "HTTP_CONNECTION",
+      #"HTTP_COOKIE",
+      #"HTTP_CACHE_CONTROL",
+      #"SERVER_NAME",
+      #"SERVER_PORT",
+      "QUERY_STRING"
+    ].freeze
+
+    @@backend, @@host, @@port = [
+      `hostname`.strip,
+      UsageTracker.settings.host,
+      UsageTracker.settings.port
+    ].each(&:freeze)
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      req_start = Time.now.to_f
+      response  = @app.call env
+      req_end   = Time.now.to_f
+
+      begin
+        data = {
+          :user_id  => env['rack.session'][:user_id],
+          :duration => ((req_end - req_start) * 1000).to_i,
+          :backend  => @@backend,
+          :xhr      => env['HTTP_X_REQUESTED_WITH'] == 'XMLHttpRequest',
+          :context  => env[Context.key],
+          :env      => {},
+          :status   => response[0] # response contains [status, headers, body]
+        }
+
+        @@headers.each {|key| data[:env][key.downcase] = env[key] unless env[key].blank?}
+
+        self.class.track(data.to_json)
+
+      rescue
+        raise unless response # Error in the application, raise it up
+
+        # Error in usage tracker itself
+        UsageTracker.log($!.message)
+        UsageTracker.log($!.backtrace.join("\n"))
+      end
+
+      return response
+    end
+
+    class << self
+      # Writes the given `data` to the reactor, using the UDP protocol.
+      # Times out after 1 second. If a write error occurs, data is lost.
+      #
+      def track(data)
+        Timeout.timeout(1) do
+          UDPSocket.open do |sock|
+            sock.connect(@@host, @@port.to_i)
+            sock.write_nonblock(data << "\n")
+          end
+        end
+
+      rescue Timeout::Error, Errno::EWOULDBLOCK, Errno::EAGAIN, Errno::EINTR
+        UsageTracker.log "Cannot track data: #{$!.message}"
+      end
+    end
+  end
+end

data/lib/usage_tracker/railtie.rb

@@ -0,0 +1,11 @@
+require 'usage_tracker/context'
+
+module UsageTracker
+  class Railtie < Rails::Railtie
+    initializer 'usage_tracker.insert_into_action_controller' do
+      ActiveSupport.on_load :action_controller do
+        ActionController::Base.instance_eval { include UsageTracker::Context }
+      end
+    end
+  end
+end

data/lib/usage_tracker/reactor.rb

@@ -0,0 +1,132 @@
+#!/usr/bin/env ruby
+
+require 'usage_tracker'
+require 'eventmachine'
+require 'json'
+
+module UsageTracker
+  module Reactor
+    # This method is called upon every data reception
+    #
+    def receive_data(data)
+      doc = parse(data)
+      if doc && check(doc)
+        store(doc)
+      end
+    end
+
+    # Debug hook
+    if UsageTracker.env == 'test'
+      alias :real_receive_data :receive_data
+      def receive_data(data)
+        UsageTracker.log.debug "Received #{data.inspect}"
+        ret = real_receive_data(data)
+        UsageTracker.log.debug ret ? "Stored #{ret}" : 'Failed to store input data'
+      end
+    end
+
+    private
+      def parse(data)
+        JSON(data).tap {|h| h.reject! {|k,v| v.nil?}}
+      rescue JSON::ParserError
+        UsageTracker.log.error "Tossing out invalid JSON #{data.inspect} (#{$!.message.inspect})"
+        return nil
+      end
+
+      def check(doc)
+        error =
+          if    !doc.kind_of?(Hash) then 'invalid'
+          elsif doc.empty?          then 'empty'
+          elsif !(missing = check_keys(doc)).empty?
+            "#{missing.join(', ')} missing"
+          end
+
+        if error
+          UsageTracker.log.error "Tossing out invalid document #{doc.inspect}: #{error}"
+          return nil
+        else
+          return true
+        end
+      end
+
+      def check_keys(doc)
+        %w( duration env status ).reject {|k| doc.has_key?(k)}
+      end
+
+      def store(doc)
+        tries = 0
+
+        begin
+          doc['_id'] = make_id
+          UsageTracker.database.save_doc(doc)
+
+        rescue RestClient::Conflict => e
+          if (tries += 1) < 10
+            UsageTracker.log.warn "Retrying to save #{doc.inspect}, try #{tries}"
+            retry
+          else
+            UsageTracker.log.error "Losing '#{doc.inspect}' because of too many conflicts"
+          end
+
+        rescue Encoding::UndefinedConversionError
+          UsageTracker.log.error "Losing '#{doc.inspect}' because #$!" # FIXME handle this error properly
+        end
+      end
+
+      # Timestamp as _id has the advantage that documents
+      # are sorted automatically by CouchDB.
+      #
+      # Eventual duplication (multiple servers) is (possibly)
+      # avoided by adding a random digit at the end.
+      #
+      def make_id
+        Time.now.to_f.to_s.ljust(16, '0') + rand(10).to_s
+      end
+  end
+
+  connect!
+
+  # Setup signal handlers
+  #
+  #  * INT, TERM: graceful exit
+  #  * USR1     : rotate logs
+  #
+  def self.sigexit(sig)
+    log "Received SIG#{sig}"
+    EventMachine.stop_event_loop
+  end
+
+  trap('INT')  { sigexit 'INT'  }
+  trap('TERM') { sigexit 'TERM' }
+  trap('USR1') { log.rotate  }
+
+  # Run the Event Loop
+  #
+  EventMachine.run do
+    begin
+      host, port = UsageTracker.settings.host, UsageTracker.settings.port
+
+      unless (1024..65535).include? port.to_i
+        raise "Please set a listening port between 1024 and 65535"
+      end
+
+      EventMachine.open_datagram_socket host, port, Reactor
+      log "Listening on #{host}:#{port} UDP"
+      write_pid!
+
+      $stderr.puts "Started, logging to #{log.path}"
+      [$stdin, $stdout, $stderr].each {|io| io.reopen '/dev/null'}
+
+    rescue Exception => e
+      message = e.message == 'no datagram socket' ? "Unable to bind #{host}:#{port}" : e
+      log.fatal message
+      $stderr.puts message unless $stderr.closed?
+      EventMachine.stop_event_loop
+      exit 1
+    end
+  end
+
+  # Goodbye!
+  #
+  log 'Exiting'
+end

data/middleware_test.rb

@@ -0,0 +1,190 @@
+################################################################
+# ATTENTION
+# make sure that a event-machine test reactor process is running
+#  ruby extras/usage_tracker/reactor.rb test
+#
+################################################################
+
+# this checks the end-point of the usage tracking (arrival in the database) ->
+# consider checking intermediate steps.......
+require 'usage_tracker'
+
+module UsageTracker
+  class IntegrationTest < ActionController::IntegrationTest
+    UsageTracker.connect!
+
+    context 'a request from a guest' do
+      should 'get tracked when successful' do
+        assert_difference 'doc_count' do
+          get '/'
+          assert_response :success
+        end
+
+        doc = last_tracking
+        assert_equal '/', doc.env.request_uri
+        assert_equal nil, doc.user_id
+        assert_equal 200, doc.status
+        assert doc.duration > 0
+      end
+
+      should 'get tracked when not found' do
+        get '/nonexistant'
+        assert_response :not_found
+
+        doc = last_tracking
+        assert_equal '/nonexistant', doc.env.request_uri
+        assert_equal 404,            doc.status
+      end
+    end
+
+    context 'a request from a logged-in user' do
+      setup do
+        @user = Factory.create(:confirmed_user)
+        post '/login', {:email => @user.email, :password => @user.password}, {'HTTPS' => 'on'}
+        assert_redirected_to plain_root_url
+      end
+
+      should 'get tracked when successful' do
+        assert_difference 'doc_count' do
+          get '/_'
+          assert_response :success
+        end
+
+        doc = last_tracking
+
+        assert_equal '/_',     doc.env.request_uri
+        assert_equal @user.id, doc.user_id
+        assert_equal 200,      doc.status
+      end
+
+      should 'get tracked when not found' do
+        get '/nonexistant'
+        assert_response :not_found
+
+        doc = last_tracking
+
+        assert_equal '/nonexistant', doc.env.request_uri
+        assert_equal @user.id,       doc.user_id
+        assert_equal 404,            doc.status
+        assert_equal false,          doc.xhr
+      end
+
+      should 'get tracked when failed' do
+        xhr :get, '/projects/1/error', {}, {'HTTPS' => 'on'}
+        assert_response :internal_server_error
+
+        doc = last_tracking
+
+        assert_equal '/projects/1/error', doc.env.request_uri
+        assert_equal @user.id,            doc.user_id
+        assert_equal 500,                 doc.status
+        assert_equal true,                doc.xhr
+        assert_equal `hostname`.strip,    doc.backend
+      end
+    end
+
+    fast_context "a search request" do
+      setup do
+        @res, @users, @assets =
+          mock_search_results_for(Array.new(2) { Factory.create(:res)  }),
+          mock_search_results_for(Array.new(3) { Factory.create(:user) }),
+          mock_search_results_for(Network::AssetsController::ContentModels.map {|name|
+            Array.new(2) { Factory(name.underscore.to_sym).reload.asset } }.flatten)
+
+        Res.stubs(:search).returns(@res)
+        User.stubs(:search).returns(@users)
+        NetworkAsset.stubs(:search).returns(@assets)
+      end
+
+      should "be tracked with results" do
+        get '/search/e'
+        assert_response :success
+
+        doc = last_tracking
+        assert !doc.context.blank?
+
+        assert_equal 'e', doc.context.query
+        assert_equal [],  doc.context.tags
+        assert_equal nil, doc.context.cat
+
+        assert_equal @res.map(&:id),    doc.context.results.res
+        assert_equal @users.map(&:id),  doc.context.results.users
+        assert_equal @assets.map(&:id), doc.context.results.assets
+      end
+
+      should "be tracked with tags" do
+        get '/search', :tag => 'a,b,c'
+        assert_response :success
+
+        doc = last_tracking
+        assert !doc.context.blank?
+
+        assert_equal '',        doc.context.query
+        assert_equal %w(a b c), doc.context.tags
+        assert_equal nil,       doc.context.cat
+      end
+
+      should "be tracked with tags and query" do
+        get '/search/antani', :tag => 'd,e,f'
+        assert_response :success
+
+        doc = last_tracking
+        assert !doc.context.blank?
+
+        assert_equal 'antani',  doc.context.query
+        assert_equal %w(d e f), doc.context.tags
+        assert_equal nil,       doc.context.cat
+      end
+
+      should "be tracked with category" do
+        cat = Factory.create(:res_category)
+        get '/search', :cat => cat.shortcut
+        assert_response :success
+
+        doc = last_tracking
+        assert !doc.context.blank?
+
+        assert_equal '',     doc.context.query
+        assert_equal [],     doc.context.tags
+        assert_equal cat.id, doc.context.cat
+      end
+
+      should "be tracked with category and query" do
+        cat = Factory.create(:res_category)
+        get '/search/res/asd', :cat => cat.shortcut
+        assert_response :success
+
+        doc = last_tracking
+        assert !doc.context.blank?
+
+        assert_equal 'asd',  doc.context.query
+        assert_equal [],     doc.context.tags
+        assert_equal cat.id, doc.context.cat
+      end
+    end
+
+    context "the middleware" do
+      should "not wait for more than a second before aborting" do
+        UDPSocket.expects(:open).once.yields(Class.new do
+          def write_nonblock(*args); sleep 0.7 end
+          def connect(*args)       ; sleep 0.7 end
+        end.new)
+
+        assert_no_difference 'doc_count' do
+          get '/_'
+          assert_response :success
+        end
+      end
+    end
+
+    def last_tracking
+      sleep 0.3
+      UsageTracker.database.view('basic/by_timestamp', :descending => true, :limit => 1).rows.first.value
+    end
+
+    def doc_count
+      sleep 0.3
+      UsageTracker.database.info['doc_count']
+    end
+  end
+end

data/panmind-usage-tracker.gemspec

@@ -0,0 +1,60 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{panmind-usage-tracker}
+  s.version = "0.4.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Marcello Barnaba", "Christian Wo\u0308rner"]
+  s.date = %q{2010-12-03}
+  s.default_executable = %q{usage_tracker}
+  s.description = %q{This software implements a Rails 3 Middleware and an EventMachine reactor to store into CouchDB the results of HTTP request processing}
+  s.email = %q{vjt@openssl.it}
+  s.executables = ["usage_tracker"]
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "bin/usage_tracker",
+    "config/usage_tracker.yml.sample",
+    "config/usage_tracker_upstart.conf",
+    "config/views.yml",
+    "lib/usage_tracker.rb",
+    "lib/usage_tracker/context.rb",
+    "lib/usage_tracker/log.rb",
+    "lib/usage_tracker/middleware.rb",
+    "lib/usage_tracker/railtie.rb",
+    "lib/usage_tracker/reactor.rb",
+    "middleware_test.rb"
+  ]
+  s.homepage = %q{http://github.com/Panmind/usage_tracker}
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Write your application request logs in CouchDB}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, ["~> 3.0"])
+      s.add_runtime_dependency(%q<eventmachine>, [">= 0"])
+      s.add_runtime_dependency(%q<couchrest>, [">= 0"])
+    else
+      s.add_dependency(%q<rails>, ["~> 3.0"])
+      s.add_dependency(%q<eventmachine>, [">= 0"])
+      s.add_dependency(%q<couchrest>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rails>, ["~> 3.0"])
+    s.add_dependency(%q<eventmachine>, [">= 0"])
+    s.add_dependency(%q<couchrest>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: panmind-usage-tracker
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
+platform: ruby
+authors: 
+- Marcello Barnaba
+- "Christian Wo\xCC\x88rner"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-03 00:00:00 +01:00
+default_executable: usage_tracker
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        version: "3.0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: eventmachine
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: couchrest
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: This software implements a Rails 3 Middleware and an EventMachine reactor to store into CouchDB the results of HTTP request processing
+email: vjt@openssl.it
+executables: 
+- usage_tracker
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- Rakefile
+- VERSION
+- bin/usage_tracker
+- config/usage_tracker.yml.sample
+- config/usage_tracker_upstart.conf
+- config/views.yml
+- lib/usage_tracker.rb
+- lib/usage_tracker/context.rb
+- lib/usage_tracker/log.rb
+- lib/usage_tracker/middleware.rb
+- lib/usage_tracker/railtie.rb
+- lib/usage_tracker/reactor.rb
+- middleware_test.rb
+- panmind-usage-tracker.gemspec
+has_rdoc: true
+homepage: http://github.com/Panmind/usage_tracker
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Write your application request logs in CouchDB
+test_files: []
+