beaver 1.0.0 → 1.1.0

data/README.rdoc

@@ -1,6 +1,6 @@
 == Beaver, chewing through logs to make something useful
 
-Beaver is a light DSL for parsing Rails production logs back into usable data. It answers questions like:
+Beaver is a light DSL and command line utility for parsing Rails production logs back into usable data. It answers questions like:
 
 * How many failed logins have there been today? Were they for the same user? From the same IP?
 * How many 500, 404, etc. errors yesterday? On what pages?
@@ -58,22 +58,30 @@ Run ''beaver'' from the command line, passing in your beaver file and some logs:
           '/var/www/rails-app/log/production.log.1']
 
   # Parse the logs, but only include requests from yesterday
-  Beaver.parse logs, :on => Date.today-1 do
+  Beaver.stream logs, :on => Date.today-1 do
     hit :failed_login, :method => :post, :path => '/login', :status => 401
     ...
   end
 
-== Use beaver like grep for Rails logs
+== Beavers love Unix
 
-It's pretty difficult to grep through a multi-line log format and output each matching multi-line event. But Beaver is up to it:
+It's difficult to grep through a multi-line log format like Rails' and output each matching multi-line event (though I hear Google is working on a 'Context-Free Grep', which may help solve that). Until then, for Rails anyway, beaver is happy to step in.
 
-  beaver --path="/widgets.*" --method=post,put /var/www/rails-app/log/production.log
+  beaver --path="/widgets" --method=post,put /var/www/rails-app/log/production.log
 
 Or format the output to a single line:
 
-  beaver --path="/widgets.*" --method=post,put /var/www/rails-app/log/production.log --print "%{ip} hit %{path} using %{method}"
+  beaver --controller=widgets /var/www/rails-app/log/production.log --print "%{ip} hit %{action} using %{method}"
 
-The command-line matchers are nearly identical to the DSL's. See more details with 'beaver --help'.
+Also accepts log content from pipes and stdin (might be a bit faster):
+
+  cat /var/www/rails-app/log/production.log* | beaver --action=edit
+
+  beaver --action=edit < /var/www/rails-app/log/production.log.1 
+
+  beaver --action=edit --stdin
+
+See all options with 'beaver --help'.
 
 == Example use with Logwatch
 This assumes 1) you're rotating your Rails logs daily and 2) you're running logwatch daily.

data/bin/beaver

@@ -4,59 +4,47 @@ require 'optparse'
 require 'rubygems'
 require 'beaver'
 
-# Parse a string from the command-line into a Date object
-def parse_date(date)
-  case date
-    when /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/ then Date.parse(date)
-    when /^-\d+$/ then Date.today + date.to_i
-    else nil
-  end
-end
-
-options = {}
+options, matchers = {}, {}
 o = OptionParser.new do |opts|
-  opts.banner = 'Usage: beaver [options] [dsl.rb...] /rails/production.log...'
-  opts.on('--path PATH', 'URL path, string or regex') { |path| options[:path] = Regexp.new(path, Regexp::IGNORECASE) }
-  opts.on('--method METHOD', 'HTTP request method(s), e.g. get or post,put') { |methods| options[:method] = methods.split(',').map { |m| m.downcase.to_sym } }
-  opts.on('--status STATUS', 'HTTP status(es), e.g. 200 or 500..503') { |s| options[:status] = s =~ /(\.+)/ ? Range.new(*s.split($1).map(&:to_i)) : s.to_i }
-  opts.on('--ip IP', 'IP address, string or regex') { |ip| options[:ip] = Regexp.new(ip) }
-  opts.on('--params PARAMS', 'Request parameters string (a Ruby Hash), string or regex') { |params| options[:params_str] = Regexp.new(params, Regexp::IGNORECASE) }
-  opts.on('--format FORMAT', 'Response format(s), e.g. html or json,xml') { |f| options[:format] = f.split(',').map(&:to_sym) }
-  opts.on('--longer-than MS', 'Minimum response time in ms') { |ms| options[:longer_than] = ms.to_i }
-  opts.on('--shorter-than MS', 'Maximum response time in ms') { |ms| options[:shorter_than] = ms.to_i }
-  opts.on('--on DATE', 'Only include log entries from the given date (yyyy-mm-dd or -n days)') { |d| options[:on] = parse_date(d) }
-  opts.on('--after DATE', 'Only include log entries from after the given date (yyyy-mm-dd or -n days)') { |d| options[:after] = parse_date(d) }
-  opts.on('--before DATE', 'Only include log entries from before the given date (yyyy-mm-dd or -n days)') { |d| options[:before] = parse_date(d) }
-  opts.on('--today', 'Alias to --on=-0') { options[:on] = Date.today }
-  opts.on('--yesterday', 'Alias to --on=-1') { options[:on] = Date.today-1 }
-  opts.on('--regex REGEX', 'A regex string to be matched against the entire request') { |r| options[:match] = Regexp.new(r, Regexp::IGNORECASE) }
-  opts.on('--print FORMAT', 'Formatted request string, e.g. "%{ip} went to %{path} passing %{params[:email]}"') { |hit| options[:hit] = hit }
+  opts.banner = 'Usage: beaver [options] [dsl.rb...] [/rails/production.log...]'
+  opts.on('--path PATH', 'URL path, string or regex') { |path| matchers[:path] = Regexp.new(path, Regexp::IGNORECASE) }
+  opts.on('--method METHOD', 'HTTP request method(s), e.g. get or post,put') { |methods| matchers[:method] = methods.split(',').map { |m| m.downcase.to_sym } }
+  opts.on('--controller CONTROLLER', 'Rails controller name or regex') { |c| matchers[:controller] = Regexp.new(c, Regexp::IGNORECASE) }
+  opts.on('--action CONTROLLER', 'Rails action name or regex') { |a| matchers[:action] = Regexp.new(a, Regexp::IGNORECASE) }
+  opts.on('--status STATUS', 'HTTP status(es), e.g. 200 or 500..503') { |s| matchers[:status] = s =~ /(\.+)/ ? Range.new(*s.split($1).map(&:to_i)) : s.to_i }
+  opts.on('--ip IP', 'IP address, string or regex') { |ip| matchers[:ip] = Regexp.new(ip) }
+  opts.on('--params PARAMS', 'Request parameters string (a Ruby Hash), string or regex') { |params| matchers[:params_str] = Regexp.new(params, Regexp::IGNORECASE) }
+  opts.on('--format FORMAT', 'Response format(s), e.g. html or json,xml') { |f| matchers[:format] = f.split(',').map(&:to_sym) }
+  opts.on('--longer-than MS', 'Minimum response time in ms') { |ms| matchers[:longer_than] = ms.to_i }
+  opts.on('--shorter-than MS', 'Maximum response time in ms') { |ms| matchers[:shorter_than] = ms.to_i }
+  opts.on('--on DATE', 'Only include log entries from the given date (yyyy-mm-dd or -n days)') { |d| matchers[:on] = Beaver::Utils.parse_date(d) }
+  opts.on('--after DATE', 'Only include log entries from after the given date (yyyy-mm-dd or -n days)') { |d| matchers[:after] = Beaver::Utils.parse_date(d) }
+  opts.on('--before DATE', 'Only include log entries from before the given date (yyyy-mm-dd or -n days)') { |d| matchers[:before] = Beaver::Utils.parse_date(d) }
+  opts.on('--today', 'Alias to --on=-0') { matchers[:on] = Date.today }
+  opts.on('--yesterday', 'Alias to --on=-1') { matchers[:on] = Date.today-1 }
+  opts.on('--regex REGEX', 'A regex string to be matched against the entire request') { |r| matchers[:match] = Regexp.new(r, Regexp::IGNORECASE) }
+  opts.on('--print FORMAT', 'Formatted request string, e.g. "%{ip} went to %{path} passing %{params[:email]}"') { |hit| options[:print] = hit }
+  opts.on('--stdin', 'Read log content from stdin (for typing/pasting)') { options[:tty] = true }
   opts.on('-v', '--version', 'Show version') { puts "beaver #{Beaver::VERSION}"; exit }
 end
 o.parse!
 
-# Separate the beaver files and log files
+# Separate the beaver files and log files, then build the Beaver arguments
 beaver_files, log_files = ARGV.uniq.partition { |a| a =~ /\.rb$/ }
+args = beaver_files.any? ? log_files << matchers : log_files
 
-# There have to be log files
-if log_files.empty?
-  puts o.banner
-  exit 1
-end
-
-# Run logs through the DSL file(s)
-if beaver_files.any?
-  STDERR.puts "WARNING --hit is ignored when running Beaver DSL files" if options[:hit]
-
-  beaver_files.map! { |b| File.open(b, &:read) }
-  Beaver.parse *[log_files, options].flatten do
+# Run Beaver
+Beaver.stream *args do
+  stdin!
+  tty! if options[:tty]
+  # Filter the logs through the DSL files
+  if beaver_files.any?
+    beaver_files.map! { |b| File.open(b, &:read) }
     beaver_files.each { |b| eval b }
-  end
-# Run logs through the CLI options
-else
-  Beaver.parse *log_files do
-    hit :cli, options do
-      puts options[:hit] ? eval('"'+options[:hit].gsub(/%\{/, '#{')+'"') : to_s << $/
+  # Filter the logs through the CLI options
+  else
+    hit :cli, matchers do
+      puts options[:print] ? eval('"'+options[:print].gsub(/%\{/, '#{')+'"') : to_s << $/
     end
   end
 end

data/lib/beaver/beaver.rb

@@ -1,40 +1,72 @@
 # Not specifically a performance analyzer (like https://github.com/wvanbergen/request-log-analyzer/wiki)
 # Rather, a DSL for finding out how people are using your Rails app (which could include performance).
+# 
+# Beaver.stream do
+#   hit :error, :status => (400..505) do
+#     puts "#{status} on #{path} at #{time} from #{ip} with #{params_str}"
+#   end
+# end
+# 
 module Beaver
-  MAJOR_VERSION, MINOR_VERSION, TINY_VERSION, PRE_VERSION = 1, 0, 0, nil
+  MAJOR_VERSION, MINOR_VERSION, TINY_VERSION, PRE_VERSION = 1, 1, 0, nil
   VERSION = [MAJOR_VERSION, MINOR_VERSION, TINY_VERSION, PRE_VERSION].compact.join '.'
 
-  # Alias to creating a new Beaver, parsing the files, and filtering them
+  # Creates a new Beaver and immediately filters the log files. This should scale well
+  # for even very large logs, at least when compared to Beaver#parse.
+  def self.stream(*args, &blk)
+    raise ArgumentError, 'You must pass a block to Beaver#stream' unless block_given?
+    Beaver.new(*args, &blk).stream
+  end
+
+  # Identical to Beaver#stream, except that the requests are retained, so you may
+  # examine them afterwards. For large logs, this may be noticibly inefficient.
   def self.parse(*args, &blk)
     raise ArgumentError, 'You must pass a block to Beaver#parse' unless block_given?
-    beaver = Beaver.new(*args)
-    beaver.parse
-    beaver.filter(&blk)
-    beaver
+    Beaver.new(*args, &blk).parse.filter
   end
 
   # Alias to creating a new Beaver
-  def self.new(*args)
-    Beaver.new(*args)
+  def self.new(*args, &blk)
+    Beaver.new(*args, &blk)
   end
 
   # The Beaver class, which keeps track of the files you're parsing, the Beaver::Dam objects you've defined,
-  # and parses and stores the matching Beaver::Request objects.
+  # and parses and filters the matching Beaver::Request objects.
+  # 
+  # beaver = Beaver.new do
+  #   hit :help, :path => '/help' do
+  #     puts "#{ip} needed help"
+  #   end
+  # end
+  # 
+  # # Method 1 - logs will be parsed and filtered line-by-line, then discarded. Performance should be constant regardless of the number of logs.
+  # beaver.stream
+  # 
+  # # Method 2 - all of the logs will be parsed at once and stored in "beaver.requests". Then each request will be filtered.
+  # # This does not scale as well, but is necessary *if you want to hang onto the parsed requests*.
+  # beaver.parse.filter
+  # 
   class Beaver
-    # The files to parse
-    attr_reader :files
+    # The log files to parse
+    attr_reader :logs
+    # Parse stdin (ignores tty)
+    attr_accessor :stdin
+    # Enables parsing from tty *if* @stdin in also true
+    attr_accessor :tty
     # The Beaver::Dam objects you're defined
     attr_reader :dams
-    # The Beaver::Request objects matched in the given files
+    # The Beaver::Request objects matched in the given log files (only availble with Beaver#parse)
     attr_reader :requests
 
     # Pass in globs or file paths. The final argument may be an options Hash.
     # These options will be applied as matchers to all hits. See Beaver::Dam for available options.
-    def initialize(*args)
+    def initialize(*args, &blk)
       @global_matchers = args.last.is_a?(Hash) ? args.pop : {}
-      @files = args.map { |a| Dir.glob(a) }
-      @files.flatten!
+      @logs = args.map { |a| Dir.glob(a) }
+      @logs.flatten!
+      @stdin, @tty = false, false
       @requests, @dams, @sums = [], {}, {}
+      instance_eval(&blk) if block_given?
     end
 
     # Creates a new Dam and appends it to this Beaver. name should be a unique symbol.
@@ -51,49 +83,118 @@ module Beaver
       @sums[name] = callback
     end
 
-    # Parse the logs and filter them through the dams
-    # "parse" must be run before this, or there will be no requests
-    def filter(&blk)
-      instance_eval(&blk) if block_given?
-      @requests.each do |req|
-        @dams.each_value do |dam|
-          if dam.matches? req
-            catch :skip do
-              req.instance_eval(&dam.callback) if dam.callback
-              dam.hits << req
-            end
+    # Parses the logs and immediately filters them through the dams. Requests are not retained,
+    # so this should scale well to very large sets of logs.
+    def stream
+      # Match the request against each dam, and run the dam's callback
+      _parse do |request|
+        hit_dams(request) do |dam|
+          dam.hits << request if @sums[dam.name]
+        end
+      end
+      # Run the callback for each summary
+      summarize_dams do |dam|
+        dam.hits.clear # Clean up
+      end
+      self
+    end
+
+    # Filter @requests through the dams. (Beaver#parse must be run before this, or there will be no @requests.)
+    # Requests will be kept around after the run.
+    def filter
+      for request in @requests
+        hit_dams(request) do |dam|
+          dam.hits << request
+        end
+      end
+      summarize_dams
+      self
+    end
+
+    # Parse the logs into @requests. This does *not* run them through the dams. To do that call Beaver#filter afterwards.
+    def parse
+      @requests.clear
+      _parse { |request| @requests << request }
+      self
+    end
+
+    # Tells this Beaver to look in STDIN for log content to parse. NOTE This ignores tty input unless you also call Beaver#tty!.
+    # 
+    # *Must* be called before "stream" or "parse" to have any effect. Returns "self," so it is chainable. Can also be used in the DSL.
+    def stdin!
+      @stdin = true
+      self
+    end
+
+    # Tells this Beaver to look in STDIN for tty input.
+    # 
+    # *Must* be called before "stream" or "parse" to have any effect. Returns "self," so it is chainable. Can also be used in the DSL.
+    def tty!
+      stdin!
+      @tty = true
+      self
+    end
+
+    private
+
+    # Run the callback on each dam matching request. Optionally pass a block, which will be passed back matching dams.
+    def hit_dams(request, &blk)
+      for dam in @dams.values
+        if dam.matches? request
+          catch :skip do
+            request.instance_eval(&dam.callback) if dam.callback
+            blk.call(dam) if block_given?
           end
         end
       end
-      @sums.each do |dam_name, callback|
+    end
+
+    # Run the summary callback for each dam that had matching requests. Optionally pass a block, which will be passed back each dam.
+    def summarize_dams(&blk)
+      for dam_name, callback in @sums
         if @dams.has_key? dam_name
-          @dams[dam_name].instance_eval(&callback) if @dams[dam_name].hits.any?
+          if @dams[dam_name].hits.any?
+            @dams[dam_name].instance_eval(&callback)
+            blk.call(@dams[dam_name]) if block_given?
+          end
         else
           STDERR.puts "WARNING You have defined a dam for '#{dam_name}', but there is no hit defined for '#{dam_name}'"
         end
       end
     end
 
-    # Parse the logs into @requests
-    def parse
-      @files.each do |file|
+    # Parses @logs into requests, and passes each request to &blk.
+    def _parse(&blk)
+      request = nil
+      # Parses a line into part of a request
+      parse_it = lambda { |line|
+        request ||= Request.for(line).new
+        if request.bad?
+          request = nil
+          next
+        end
+        request << line
+        if request.completed?
+          blk.call(request)
+          request = nil
+        end
+      }
+
+      # Parse stdin
+      if @tty
+        STDIN.read.each_line &parse_it # Read entire stream, then parse it - looks much better to the user
+      elsif !STDIN.tty?
+        STDIN.each_line &parse_it
+      end if @stdin
+      request = nil
+
+      # Parse log files
+      for file in @logs
         zipped = file =~ /\.gz\Z/i
         next if zipped and not defined? Zlib
         File.open(file, 'r:UTF-8') do |f|
           handle = (zipped ? Zlib::GzipReader.new(f) : f)
-          request = nil
-          handle.each_line do |line|
-            request = Request.for(line).new if request.nil?
-            if request.bad?
-              request = nil
-              next
-            end
-            request << line
-            if request.completed?
-              @requests << request
-              request = nil
-            end
-          end
+          handle.each_line &parse_it
         end
       end
     end

data/lib/beaver/dam.rb

@@ -7,6 +7,10 @@ module Beaver
   #  :path => String for exact match, or Regex
   #
   #  :method => A Symbol of :get, :post, :put or :delete, or any array of any (reads the magic _method field if present)
+  # 
+  #  :controller => A String like 'FooController' or a Regex like /foo/i
+  # 
+  #  :action => A String like 'index' or a Regex like /(index)|(show)/
   #
   #  :status => A Fixnum like 404 or a Range like (500..503)
   # 
@@ -58,20 +62,20 @@ module Beaver
     # Returns true if the given Request hits this Dam, false if not.
     def matches?(request)
       return false if request.final?
-      return false unless @match_path_s.nil? or @match_path_s == request.path
-      return false unless @match_path_r.nil? or @match_path_r =~ request.path
+      return false unless @match_path.nil? or @match_path === request.path
       return false unless @match_longer.nil? or @match_longer < request.ms
       return false unless @match_shorter.nil? or @match_shorter > request.ms
       return false unless @match_method_s.nil? or @match_method_s == request.method
       return false unless @match_method_a.nil? or @match_method_a.include? request.method
       return false unless @match_status.nil? or @match_status === request.status
-      return false unless @match_ip_s.nil? or @match_ip_s == request.ip
-      return false unless @match_ip_r.nil? or @match_ip_r =~ request.ip
+      return false unless @match_controller.nil? or @match_controller === request.controller
+      return false unless @match_action.nil? or @match_action === request.action.to_s or @match_action == request.action
+      return false unless @match_ip.nil? or @match_ip === request.ip
       return false unless @match_format_s.nil? or @match_format_s == request.format
       return false unless @match_format_a.nil? or @match_format_a.include? request.format
       return false unless @match_before.nil? or @match_before > request.time
       return false unless @match_after.nil? or @match_after < request.time
-      return false unless @match_on.nil? or (@match_on.year == request.time.year and @match_on.month == request.time.month and @match_on.day == request.time.day)
+      return false unless @match_on.nil? or @match_on == request.date
       return false unless @match_params_str.nil? or @match_params_str =~ request.params_str
       return false unless @match_r.nil? or @match_r =~ request.to_s
       return false unless @match_params.nil? or matching_hashes?(@match_params, request.params)
@@ -105,32 +109,44 @@ module Beaver
 
     # Parses and checks the validity of the matching options passed to the Dam.
     def set_matchers(matchers)
-      case matchers[:path].class.name
-        when String.name then @match_path_s = matchers[:path]
-        when Regexp.name then @match_path_r = matchers[:path]
-        else raise ArgumentError, "Path must be a String or a Regexp (it's a #{matchers[:path].class.name})"
+      if matchers[:path].respond_to? :===
+        @match_path = matchers[:path]
+      else
+        raise ArgumentError, "Path must respond to the '===' method; try a String or a Regexp (it's a #{matchers[:path].class.name})"
       end if matchers[:path]
 
-      case matchers[:method].class.name
-        when Symbol.name then @match_method_s = matchers[:method].to_s.downcase.to_sym
-        when Array.name then @match_method_a = matchers[:method].map { |m| m.to_s.downcase.to_sym }
+      case
+        when matchers[:method].is_a?(Symbol) then @match_method_s = matchers[:method].to_s.downcase.to_sym
+        when matchers[:method].is_a?(Array) then @match_method_a = matchers[:method].map { |m| m.to_s.downcase.to_sym }
         else raise ArgumentError, "Method must be a Symbol or an Array (it's a #{matchers[:method].class.name})"
       end if matchers[:method]
 
+      if matchers[:controller].respond_to? :===
+        @match_controller = matchers[:controller]
+      else
+        raise ArgumentError, "Controller must respond to the '===' method; try a String or a Regexp (it's a #{matchers[:controller].class.name})"
+      end if matchers[:controller]
+
+      if matchers[:action].respond_to? :=== or matchers[:action].is_a? Symbol
+        @match_action = matchers[:action]
+      else
+        raise ArgumentError, "Action must respond to the '===' method or be a Symbol; try a String, Symbol or a Regexp (it's a #{matchers[:action].class.name})"
+      end if matchers[:action]
+
       case matchers[:status].class.name
         when Fixnum.name, Range.name then @match_status = matchers[:status]
         else raise ArgumentError, "Status must be a Fixnum or a Range (it's a #{matchers[:status].class.name})"
       end if matchers[:status]
 
-      case matchers[:ip].class.name
-        when String.name then @match_ip_s = matchers[:ip]
-        when Regexp.name then @match_ip_r = matchers[:ip]
-        else raise ArgumentError, "IP must be a String or a Regexp (it's a #{matchers[:ip].class.name})"
+      if matchers[:ip].respond_to? :===
+        @match_ip = matchers[:ip]
+      else
+        raise ArgumentError, "IP must respond to the '===' method; try a String or a Regexp (it's a #{matchers[:ip].class.name})"
       end if matchers[:ip]
 
-      case matchers[:format].class.name
-        when Symbol.name then @match_format_s = matchers[:format].to_s.downcase.to_sym
-        when Array.name then @match_format_a = matchers[:format].map { |f| f.to_s.downcase.to_sym }
+      case
+        when matchers[:format].is_a?(Symbol) then @match_format_s = matchers[:format].to_s.downcase.to_sym
+        when matchers[:format].is_a?(Array) then @match_format_a = matchers[:format].map { |f| f.to_s.downcase.to_sym }
         else raise ArgumentError, "Format must be a Symbol or an Array (it's a #{matchers[:format].class.name})"
       end if matchers[:format]
 
@@ -144,33 +160,27 @@ module Beaver
         else raise ArgumentError, "shorter_than must be a Fixnum (it's a #{matchers[:shorter_than].class.name})"
       end if matchers[:shorter_than]
 
-      if matchers[:before]
-        @match_before = if matchers[:before].is_a? Time
-          matchers[:before]
-        elsif matchers[:before].is_a? Date
-          Utils::NormalizedTime.new(matchers[:before].year, matchers[:before].month, matchers[:before].day)
-        else
-          raise ArgumentError, "before must be a Date or Time (it's a #{matchers[:before].class.name})"
-        end
-      end
+      @match_before = if matchers[:before].is_a? Time
+        matchers[:before]
+      elsif matchers[:before].is_a? Date
+        Utils::NormalizedTime.new(matchers[:before].year, matchers[:before].month, matchers[:before].day)
+      else
+        raise ArgumentError, "before must be a Date or Time (it's a #{matchers[:before].class.name})"
+      end if matchers[:before]
 
-      if matchers[:after]
-        @match_after = if matchers[:after].is_a? Time
-          matchers[:after]
-        elsif matchers[:after].is_a? Date
-          Utils::NormalizedTime.new(matchers[:after].year, matchers[:after].month, matchers[:after].day)
-        else
-          raise ArgumentError, "after must be a Date or Time (it's a #{matchers[:after].class.name})"
-        end
-      end
+      @match_after = if matchers[:after].is_a? Time
+        matchers[:after]
+      elsif matchers[:after].is_a? Date
+        Utils::NormalizedTime.new(matchers[:after].year, matchers[:after].month, matchers[:after].day)
+      else
+        raise ArgumentError, "after must be a Date or Time (it's a #{matchers[:after].class.name})"
+      end if matchers[:after]
 
-      if matchers[:on]
-        if matchers[:on].is_a? Date
-          @match_on = matchers[:on]
-        else
-          raise ArgumentError, "on must be a Date (it's a #{matchers[:on].class.name})"
-        end
-      end
+      if matchers[:on].is_a? Date
+        @match_on = matchers[:on]
+      else
+        raise ArgumentError, "on must be a Date (it's a #{matchers[:on].class.name})"
+      end if matchers[:on]
 
       case matchers[:params_str].class.name
         when Regexp.name then @match_params_str = matchers[:params_str]

data/lib/beaver/parsers/rails.rb

@@ -7,6 +7,8 @@ module Beaver
 
       REGEX_METHOD = /^Started ([A-Z]+)/
       REGEX_METHOD_OVERRIDE = /"_method"=>"([A-Z]+)"/i
+      REGEX_CONTROLLER = /Processing by (\w+Controller)#/
+      REGEX_ACTION = /Processing by \w+Controller#(\w+) as/
       REGEX_COMPLETED = /^Completed (\d+)/
       REGEX_PATH = /^Started \w{3,4} "([^"]+)"/
       REGEX_PARAMS_STR = /^  Parameters: (\{.+\})$/
@@ -44,6 +46,18 @@ module Beaver
         m ? m.captures.first.downcase.to_sym : :unknown
       end
 
+      # Parses the name of the Rails controller which handled the request
+      def parse_controller
+        c = REGEX_CONTROLLER.match(@lines) if c.nil?
+        c ? c.captures.first : BLANK_STR
+      end
+
+      # Parses the name of the Rails controller action which handled the request
+      def parse_action
+        a = REGEX_ACTION.match(@lines) if a.nil?
+        a ? a.captures.first.to_sym : :unknown
+      end
+
       # Parses and returns the response status
       def parse_status
         m = REGEX_COMPLETED.match(@lines)
@@ -80,6 +94,12 @@ module Beaver
         m ? m.captures.first.to_i : 0
       end
 
+      # Parses and returns the time at which the request was made
+      def parse_date
+        m = REGEX_TIME.match(@lines)
+        m ? Date.parse(m.captures.first) : nil
+      end
+
       # Parses and returns the time at which the request was made
       def parse_time
         m = REGEX_TIME.match(@lines)

data/lib/beaver/request.rb

@@ -1,3 +1,4 @@
+require 'date'
 require 'time'
 
 module Beaver
@@ -49,6 +50,16 @@ module Beaver
       @method ||= parse_method
     end
 
+    # Returns the class name of the Rails controller that handled the request
+    def controller
+      @controller ||= parse_controller
+    end
+
+    # Returns the class name of the Rails controller action that handled the request
+    def action
+      @action ||= parse_action
+    end
+
     # Returns the response status
     def status
       @status ||= parse_status
@@ -79,6 +90,11 @@ module Beaver
       @ms ||= parse_ms
     end
 
+    # Returns the date on which the request was made
+    def date
+      @date ||= parse_date
+    end
+
     # Returns the time at which the request was made
     def time
       @time ||= parse_time
@@ -113,7 +129,17 @@ module Beaver
 
     # Parses and returns the request method
     def parse_method
-      :method
+      :unknown
+    end
+
+    # Parses the name of the Rails controller which handled the request
+    def parse_controller
+      BLANK_STR
+    end
+
+    # Parses the name of the Rails controller action which handled the request
+    def parse_action
+      :unknown
     end
 
     # Parses and returns the response status
@@ -138,7 +164,7 @@ module Beaver
 
     # Parses and returns the respones format
     def parse_format
-      :format
+      :unknown
     end
 
     # Parses and returns the number of milliseconds it took for the request to complete
@@ -146,6 +172,11 @@ module Beaver
       0
     end
 
+    # Parses and returns the date on which the request was made
+    def parse_date
+      nil
+    end
+
     # Parses and returns the time at which the request was made
     def parse_time
       nil

data/lib/beaver/utils.rb

@@ -92,6 +92,15 @@ module Beaver
       YAML.load s
     end
 
+    # Parse a string (from a command-line arg) into a Date object
+    def self.parse_date(date)
+      case date
+        when /^[0-9]{4}-[0-9]{2}-[0-9]{2}$/ then Date.parse(date)
+        when /^-\d+$/ then Date.today + date.to_i
+        else nil
+      end
+    end
+
     # Normalizes Time.new across Ruby 1.8 and 1.9.
     # Accepts the same arguments as Time.
     class NormalizedTime < ::Time

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
+  - 1
   - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Jordan Hollinger
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-03 00:00:00 -05:00
+date: 2011-12-08 00:00:00 -05:00
 default_executable: 
 dependencies: []