beaver 0.0.1

data/LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2011 Jordan Hollinger
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.rdoc

@@ -0,0 +1,105 @@
+== 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:
+
+* 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?
+* How many Widgets were created yesterday, and with what data?
+* Did anyone submit a form with the words "kill them all"? Yikes.
+
+Beaver is *not* intended as a replacement for something like Google Analytics, as it is trying to answer some differents kinds of questions.
+Rails logs contain some great information, but I've never found a good tool for using them programatically (except for speed analyzers).
+Hopefully Beaver can fill that niche for you. Personally I find it quite useful with Logwatch.
+
+Read the full documentation at http://jordanhollinger.com/docs/beaver/. The Beaver::Dam and Beaver::Request classes
+are probably what you're after.
+
+== Installation
+Beaver is still somewhat experimental, but it has proved stable and robust enough for a non-beta release.
+
+  [sudo] gem install beaver
+
+== Use the command-line Beaver
+Write your beaver file:
+
+  hit :failed_login, :method => :post, :path => '/login', :status => 401
+
+  hit :new_widgets, :path => '/widgets', :method => :post, :status => 302 do
+    puts "A Widget named #{params[:widget][:name]} was created!"
+  end
+
+  hit :help, :path => %r|^/help| do
+    skip! if path == '/help/page_i_want_to_ignore'
+    puts "#{ip} looked for help at #{path}"
+  end
+
+  hit :server_error, :status => (500..503)
+
+  dam :failed_login do
+    puts "Failed logins:"
+    hits.group_by { |h| h.params[:username] } do |user, fails|
+      puts " #{user}"
+      fails.each do |hit|
+        puts "  from #{hit.ip} at #{hit.time.to_s}"
+      end
+    end
+  end
+
+  dam :server_errors do
+    puts "Server errors:"
+    hits.group_by(&:status) do |status, errors|
+      puts " There were #{errors.size} #{status} errors"
+    end
+  end
+
+Run ''beaver'' from the command line, passing in your beaver file and some logs:
+
+  beaver my_beaver_file.rb /var/www/rails-app/log/production.log*
+
+== Example use with Logwatch
+This assumes 1) you're rotating your Rails logs daily and 2) you're running logwatch daily.
+
+Check your beaver DSL file into your Rails app, maybe under /script.
+
+Add a logwatch config file for your new service at /etc/logwatch/conf/services/your_app.conf:
+
+  Title = "Your Rails App"
+  LogFile = NONE
+
+In /etc/logwatch/scripts/services/your_app:
+
+  beaver /var/www/your_app/script/beaver.rb --yesterday /var/www/your_app/log/production.log{,.1}
+
+== Use your own Beaver
+Use Beaver like a library:
+
+  require 'rubygems'
+  require 'beaver'
+
+  # Logs from the last day or so
+  logs = ['/var/www/rails-app/log/production.log',
+          '/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
+    # Same DSL as above
+    hit :failed_login, :method => :post, :path => '/login', :status => 401
+    ...
+  end
+
+== Your Rails app should return appropriate HTTP statuses
+Rails does a lot of great things for us, but one thing largely up to us are
+HTTP status codes. For example, your failed logins are probably returning
+200 when they should arguably be returning 400 or 401.
+
+  render :action => :login, :status => 401
+
+See, it's easy. And very useful to Beaver.
+
+== TODO
+* Add support for Apache/Nginx/Rack::CommonLogger
+
+== License
+Copyright 2011 Jordan Hollinger
+
+Licensed under the Apache License

data/bin/beaver

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'rubygems'
+require 'beaver'
+
+#
+# This application was installed by RubyGems as part of the 'beaver' gem.
+#
+
+# 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 = {}
+o = OptionParser.new do |opts|
+  opts.banner = 'Usage: beaver dams.rb [options] /path/to/rails/production.log [/another/log [/yet/another/log]]'
+  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 }
+end
+o.parse!
+
+if ARGV.size < 2
+  puts o.banner
+  exit 1
+end
+
+beaver_file = File.open(ARGV.shift, &:read)
+Beaver.parse *[ARGV, options].flatten do
+  eval beaver_file
+end

data/lib/beaver.rb

@@ -0,0 +1,12 @@
+begin
+  require 'zlib'
+rescue LoadError
+  $stderr.puts "Zlib not available; compressed log files will be skipped."
+end
+
+require 'beaver/utils'
+require 'beaver/beaver'
+require 'beaver/dam'
+require 'beaver/request'
+
+require 'beaver/parsers/rails'

data/lib/beaver/beaver.rb

@@ -0,0 +1,94 @@
+# 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).
+module Beaver
+  # Alias to creating a new Beaver, parsing the files, and filtering them
+  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
+  end
+
+  # Alias to creating a new Beaver
+  def self.new(*args)
+    Beaver.new(*args)
+  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.
+  class Beaver
+    # The files to parse
+    attr_reader :files
+    # The Beaver::Dam objects you're defined
+    attr_reader :dams
+    # The Beaver::Request objects matched in the given files
+    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)
+      @global_matchers = args.last.is_a?(Hash) ? args.pop : {}
+      @files = args.map { |a| Dir.glob(a) }
+      @files.flatten!
+      @requests, @dams, @sums = [], {}, {}
+    end
+
+    # Creates a new Dam and appends it to this Beaver. name should be a unique symbol.
+    # See Beaver::Dam for available options.
+    def hit(dam_name, matchers={}, &callback)
+      raise ArgumentError, "A dam named #{dam_name} already exists" if @dams.has_key? dam_name
+      matchers = @global_matchers.merge matchers
+      @dams[dam_name] = Dam.new(dam_name, matchers, &callback)
+    end
+
+    # Define a sumarry for a Dam
+    def dam(name, &callback)
+      raise ArgumentError, "Unable to find a Dam named #{name}" unless @dams.has_key? name
+      @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
+          end
+        end
+      end
+      @sums.each do |dam_name, callback|
+        @dams[dam_name].instance_eval(&callback) if @dams[dam_name].hits.any?
+      end
+    end
+
+    # Parse the logs into @requests
+    def parse
+      @files.each do |file|
+        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
+        end
+      end
+    end
+  end
+end

data/lib/beaver/dam.rb

@@ -0,0 +1,181 @@
+module Beaver
+  # A Dam "traps" certain Requests, using one or more matching options. A request must meet *all* of the 
+  # matching options specified.
+  # 
+  # Matchers:
+  #
+  #  :path => String for exact match, or Regex
+  #
+  #  :method => A Symbol of :get, :post, :update or :delete, or any array of any (reads the magic _method field if present)
+  #
+  #  :status => A Fixnum like 404 or a Range like (500..503)
+  # 
+  #  :ip => String for exact match, or Regex
+  # 
+  #  :longer_than => Fixnum n. Matches any request which took longer than n milliseconds to complete.
+  # 
+  #  :shorter_than => Fixnum n. Matches any request which took less than n milliseconds to complete.
+  # 
+  #  :before => Date or Time for which the request must have ocurred before
+  # 
+  #  :after => Date or Time for which the request must have ocurred after
+  # 
+  #  :on => Date - the request must have ocurred on this date
+  # 
+  #  :params_str => A regular expressing matching the Parameters string
+  # 
+  #  :params => A Hash of Symbol=>String/Regexp pairs: {:username => 'bob', :email => /@gmail\.com$/}. All must match.
+  #
+  #  :match => A "catch-all" Regex that will be matched against the entire request string
+  # 
+  # The last argument may be a block, which will be called everytime this Dam is hit.
+  # The block will be run in the context of the Request object. This can be used for 
+  # further checks or for reporting purposes.
+  class Dam
+    # The symbol name of this Beaver::Dam
+    attr_reader :name
+    # An optional callback when a Beaver::Request hits this Dam
+    attr_reader :callback
+    # An array of Beaver::Request objects that have hit this Dam
+    attr_reader :hits
+
+    # Name should be a unique symbol. Matchers is an options Hash. The callback will be evauluated within
+    # the context of a Beaver::Request.
+    def initialize(name, matchers, &callback)
+      @name = name
+      @callback = callback
+      @hits = []
+      set_matchers(matchers)
+    end
+
+    # Returns an array of IP address that hit this Dam.
+    def ips
+      @ips ||= @hits.map(&:ip).uniq
+    end
+
+    # 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_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_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_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)
+      return true
+    end
+
+    private
+
+    # Recursively compares to Hashes. If all of Hash A is in Hash B, they match.
+    def matching_hashes?(a,b)
+      intersecting_keys = a.keys & b.keys
+      if intersecting_keys.any?
+        a_values = a.values_at(*intersecting_keys)
+        b_values = b.values_at(*intersecting_keys)
+        indicies = (0..b_values.size-1)
+        indicies.all? do |i|
+          if a_values[i].is_a? String
+            a_values[i] == b_values[i]
+          elsif a_values[i].is_a?(Regexp) and b_values[i].is_a?(String)
+            a_values[i] =~ b_values[i]
+          elsif a_values[i].is_a?(Hash) and b_values[i].is_a?(Hash)
+            matching_hashes? a_values[i], b_values[i]
+          else
+            false
+          end
+        end
+      else
+        false
+      end
+    end
+
+    # 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})"
+      end if matchers[:path]
+
+      case matchers[:method].class.name
+        when Symbol.name then @match_method_s = matchers[:method]
+        when Array.name then @match_method_a = matchers[:method]
+        else raise ArgumentError, "Method must be a Symbol or an Array (it's a #{matchers[:method].class.name})"
+      end if matchers[:method]
+
+      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_status_s = matchers[:ip]
+        when Regexp.name then @match_status_r = matchers[:ip]
+        else raise ArgumentError, "IP must be a String or a Regexp (it's a #{matchers[:ip].class.name})"
+      end if matchers[:ip]
+
+      case matchers[:longer_than].class.name
+        when Fixnum.name then @match_longer = matchers[:longer_than]
+        else raise ArgumentError, "longer_than must be a Fixnum (it's a #{matchers[:longer_than].class.name})"
+      end if matchers[:longer_than]
+
+      case matchers[:shorter_than].class.name
+        when Fixnum.name then @match_shorter = matchers[:shorter_than]
+        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
+
+      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
+
+      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
+
+      case matchers[:params_str].class.name
+        when Regexp.name then @match_params_str = matchers[:params_str]
+        else raise ArgumentError, "Params String must be a Regexp (it's a #{matchers[:params_str].class.name})"
+      end if matchers[:params_str]
+
+      case matchers[:params].class.name
+        when Hash.name then @match_params = matchers[:params]
+        else raise ArgumentError, "Params must be a String or a Regexp (it's a #{matchers[:params].class.name})"
+      end if matchers[:params]
+
+      case matchers[:match].class.name
+        when Regexp.name then @match_r = matchers[:match]
+        else raise ArgumentError, "Match must be a Regexp (it's a #{matchers[:match].class.name})"
+      end if matchers[:match]
+    end
+  end
+end

data/lib/beaver/parsers/rails.rb

@@ -0,0 +1,83 @@
+module Beaver
+  module Parsers
+    # This appears to work with Rails 3 logs
+    class Rails < Request
+      # Tell the Request class to use this parser to parse logs
+      Request << self
+
+      REGEX_METHOD = /^Started ([A-Z]+)/
+      REGEX_METHOD_OVERRIDE = /"_method"=>"([A-Z]+)"/i
+      REGEX_COMPLETED = /^Completed (\d+)/
+      REGEX_PATH = /^Started \w{3,4} "([^"]+)"/
+      REGEX_PARAMS_STR = /^  Parameters: (\{.+\})$/
+      REGEX_IP = /" for (\d+[\d.]+) at /
+      REGEX_MS = / in (\d+)ms/
+      # Depending on the version of Rails, the time format may be wildly different
+      REGEX_TIME = / at ([a-z0-9:\+\- ]+)$/i
+
+      # Returns true if the given lines look like a Rails request
+      def self.match?(lines)
+        REGEX_METHOD =~ lines
+      end
+
+      # Returns true, always
+      def valid?; true; end
+
+      # Returns true if/when we have the final line of the multi-line Rails request
+      def completed?
+        REGEX_COMPLETED =~ @lines
+      end
+
+      protected
+
+      # Parses and returns the request path
+      def parse_path
+        m = REGEX_PATH.match(@lines)
+        m ? m.captures.first : BLANK_STR
+      end
+
+      # Parses and returns the request method
+      def parse_method
+        m = REGEX_METHOD_OVERRIDE.match(@lines)
+        m = REGEX_METHOD.match(@lines) if m.nil?
+        m ? m.captures.first.downcase.to_sym : :method
+      end
+
+      # Parses and returns the response status
+      def parse_status
+        m = REGEX_COMPLETED.match(@lines)
+        m ? m.captures.first.to_i : 0
+      end
+
+      # Parses and returns the request parameters as a String
+      def parse_params_str
+        m = REGEX_PARAMS_STR.match(@lines)
+        m ? m.captures.first : BLANK_STR
+      end
+
+      # Parses and returns the request parameters as a Hash (relatively expensive)
+      def parse_params
+        p = params_str
+        p.empty? ? BLANK_HASH : Utils.str_to_hash(p)
+      end
+
+      # Parses and returns the request's IP address
+      def parse_ip
+        m = REGEX_IP.match(@lines)
+        m ? m.captures.first : BLANK_STR
+      end
+
+      # Parses and returns the number of milliseconds it took for the request to complete
+      def parse_ms
+        m = REGEX_MS.match(@lines)
+        m ? m.captures.first.to_i : 0
+      end
+
+      # Parses and returns the time at which the request was made
+      def parse_time
+        m = REGEX_TIME.match(@lines)
+        m ? Time.parse(m.captures.first) : nil
+      end
+    end
+  end
+end

data/lib/beaver/request.rb

@@ -0,0 +1,150 @@
+require 'time'
+
+module Beaver
+  # Represents a single request from the logs.
+  class Request
+    BLANK_STR = ''
+    BLANK_HASH = {}
+
+    # Holds the Parser classes used to parser requests
+    @types = []
+
+    # Add a child Request parser.
+    def self.<<(type)
+      @types << type
+    end
+
+    # Returns the correct Request parser class for the given log lines. If one cannot be found,
+    # the BadRequest class is returned, which the caller will want to ignore.
+    def self.for(lines)
+      @types.select { |t| t.match? lines }.first || BadRequest
+    end
+
+    # Accepts a String of log lines, presumably ones which belong to a single request.
+    def initialize(lines=nil)
+      @lines = lines || ''
+      @final = false
+    end
+
+    # Returns the log lines that make up this Request.
+    def to_s; @lines; end
+
+    # Returns true if this is a "good" request.
+    def good?; true; end
+    # Returns true if this is a "bad" request.
+    def bad?; not good?; end
+
+    # Append a log line
+    def <<(line)
+      @lines << line << $/
+    end
+
+    # Returns the request path
+    def path
+      @path ||= parse_path
+    end
+
+    # Returns the request method
+    def method
+      @method ||= parse_method
+    end
+
+    # Returns the response status
+    def status
+      @status ||= parse_status
+    end
+
+    # Returns the request parameters as a String
+    def params_str
+      @params_str ||= parse_params_str
+    end
+
+    # Returns the request parameters as a Hash (this is more expensive than Request#params_str)
+    def params
+      @params ||= parse_params
+    end
+
+    # Returns the IP address of the request
+    def ip
+      @ip ||= parse_ip
+    end
+
+    # Returns the number of milliseconds it took for the request to complete
+    def ms
+      @ms ||= parse_ms
+    end
+
+    # Returns the time at which the request was made
+    def time
+      @time ||= parse_time
+    end
+
+    # When called inside of a Beaver::Dam#hit block, this Request will *not* be matched.
+    def skip!
+      throw :skip
+    end
+
+    # When called inside of a Beaver::Dam#hit block, this Request will not match against any other Beaver::Dam.
+    def final!
+      @final = true
+    end
+
+    # Returns true if this Request should not be matched against any more Dams.
+    def final?
+      @final
+    end
+
+    # Returns true if the request has all the information it needs to be properly parsed
+    def completed?
+      true
+    end
+
+    protected
+
+    # Parses and returns the request path
+    def parse_path
+      BLANK_STR
+    end
+
+    # Parses and returns the request method
+    def parse_method
+      :method
+    end
+
+    # Parses and returns the response status
+    def parse_status
+      0
+    end
+
+    # Parses and returns the request params as a String
+    def parse_params_str
+      BLANK_STR
+    end
+
+    # Parses and returns the request params as a Hash
+    def parse_params
+      BLANK_HASH
+    end
+
+    # Parses and returns the request IP address
+    def parse_ip
+      BLANK_STR
+    end
+
+    # Parses and returns the number of milliseconds it took for the request to complete
+    def parse_ms
+      0
+    end
+
+    # Parses and returns the time at which the request was made
+    def parse_time
+      nil
+    end
+  end
+
+  # Represents a BadRequest that no parser could figure out.
+  class BadRequest < Request
+    # Returns false, always
+    def good?; false; end
+  end
+end

data/lib/beaver/utils.rb

@@ -0,0 +1,107 @@
+require 'yaml'
+require 'time'
+
+module Beaver
+  # Sundry utility methods and classes for use by Beaver
+  module Utils
+    LBRACE, RBRACE = '{', '}'
+    LBRACKET, RBRACKET = '[', ']'
+    QUOTE = '"'
+    ESCAPE = '\\'
+    EQUAL = '='
+    COLIN = ':'
+    TO_SPACE = ['>']
+    SPACE = ' '
+    COMMA = ','
+    LETTER_REGEX = /^[a-z]$/i
+
+    # Converts a string representation of a Hash into YAML, then into a Hash.
+    # This is targeted towards the Parameters value in Rails logs. It is assumed that every key is a represented as a String in the logs.
+    # All keys, except for numeric keys, will be converted to Symbols.
+    def self.str_to_hash(str)
+      s = ''
+      indent = 0
+      state = :pre_key
+      i = 0
+      str.each_char do |c|
+        i += 1
+        case c
+          when QUOTE
+            case state
+              when :pre_key
+                s << (SPACE * indent)
+                s << COLIN if str[i,1] =~ LETTER_REGEX
+                state = :key
+                next
+              when :key
+                s << COLIN << SPACE
+                state = :pre_val
+                next
+              when :pre_val, :escape
+                state = :val
+                next
+              when :val
+                state = :pre_key
+                s << "\n"
+                next
+            end
+          when LBRACE
+            case state
+              # Hash as a value, starting a new indent level
+              when :pre_val
+                state = :pre_key
+                indent += 2
+                s << "\n"# << (SPACE * indent)
+                next
+              when :pre_key
+                next
+            end
+          when RBRACE
+            case state
+              when :pre_key
+                indent -= 2 if indent > 0
+            end
+          when LBRACKET
+            case state
+              when :pre_val
+                state = :val_array
+            end
+          when RBRACKET
+            case state
+              when :val_array
+                state = :val_array_end
+            end
+          when ESCAPE
+            if state == :val
+              state = :escape
+              next
+            end
+        end
+
+        case state
+          when :key, :val, :val_array
+            s << c
+          when :escape
+            s << c
+            state = :val
+          when :val_array_end
+            s << c << "\n"
+            state = :pre_key
+        end
+      end
+      YAML.load s
+    end
+
+    # Normalizes Time.new across Ruby 1.8 and 1.9.
+    # Accepts the same arguments as Time.
+    class NormalizedTime < ::Time
+      if RUBY_VERSION < '1.9'
+        # Returns a new NormalizedTime object.
+        def self.new(*args)
+          args.pop if args.last.is_a? String
+          local(*args)
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: beaver
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jordan Hollinger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-09-24 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: A simple DSL for helping you discover what people are doing with your Rails app
+email: jordan@jordanhollinger.com
+executables: 
+- beaver
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/beaver.rb
+- lib/beaver/dam.rb
+- lib/beaver/beaver.rb
+- lib/beaver/request.rb
+- lib/beaver/parsers/rails.rb
+- lib/beaver/utils.rb
+- README.rdoc
+- LICENSE
+- bin/beaver
+has_rdoc: true
+homepage: http://github.com/jhollinger/beaver
+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: Rails production log parser
+test_files: []
+