beaver 1.1.0 → 1.2.0

data/README.rdoc

@@ -6,6 +6,7 @@ Beaver is a light DSL and command line utility for parsing Rails production logs
 * 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.
+* Rails 3.2 tagged logging is cool, but what's a good way to review them?
 
 Read the full documentation at {jordanhollinger.com/docs/beaver/}[http://jordanhollinger.com/docs/beaver/].
 For a full list of matchers available to "hit", see the Beaver::Dam class. For a full list of methods available inside a "hit" block, or to members
@@ -26,6 +27,10 @@ of the "hits" array in a "dam" block, see the Beaver::Request class.
     puts "#{ip} looked for help at #{path}"
   end
 
+  hit :tagged => 'user 1' do
+    puts "user 1 was tagged at #{path} - other tags were: #{tags.join(', ')}"
+  end
+
   hit :server_error, :status => (500..503)
 
   dam :failed_login do
@@ -67,7 +72,7 @@ Run ''beaver'' from the command line, passing in your beaver file and some logs:
 
 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 --tagged=tag1,tag2 /var/www/rails-app/log/production.log
 
 Or format the output to a single line:
 
@@ -104,6 +109,42 @@ HTTP status codes. For example, your failed logins are probably returning
 
   render :action => :login, :status => 401
 
+A detailed description of each status code and when to use it can be found at {www.w3.org}[http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html].
+
+== Complex tag querying
+Beaver supports complex Rails Tagged Logger tag quering, in both DSL and command-line modes.
+
+=== DSL
+
+  # Matches any request tagged with "foo"
+  hit :tagged, :tagged => 'foo'
+  # Could also be written as ['foo']
+
+  # Matches any request tagged with "foo" AND "bar"
+  hit :tagged_with_all, :tagged => 'foo, bar'
+  # Could also be written ['foo', 'bar']
+
+  # Matches any request tagged with "foo" OR "bar"
+  hit :tagged_with_any, :tagged => [['foo'], ['bar']]
+
+  # Matches any request tagged with ("foo" AND "bar") OR ("bar" AND "baz") OR "yay"
+  hit :tagged_and_or_and_or, :tagged => [['foo', 'foop'], ['bar', 'baz'], ['yay']]
+  # Could also be written ['foo, foop', 'bar, baz', 'yay']
+
+=== Command-line
+
+  # Matches any request tagged with "foo"
+  beaver --tagged foo production.log
+
+  # Matches any request tagged with "foo" AND "bar"
+  beaver --tagged foo,bar production.log
+
+  # Matches any request tagged with "foo" OR "bar"
+  beaver --tagged foo --tagged bar production.log
+
+  # Matches any request tagged with ("foo" AND "foop") OR ("bar" AND "baz") OR "yay"
+  beaver --tagged foo,foop --taged bar,baz --tagged yay production.log
+
 == License
 Copyright 2011 Jordan Hollinger
 

data/bin/beaver

@@ -13,6 +13,7 @@ o = OptionParser.new do |opts|
   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('--tagged TAGS', 'Comma-separated Rails Tagged Logger tags') { |tags| (matchers[:tagged] ||= []) << tags }
   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 }

data/lib/beaver/beaver.rb

@@ -8,7 +8,7 @@
 # end
 # 
 module Beaver
-  MAJOR_VERSION, MINOR_VERSION, TINY_VERSION, PRE_VERSION = 1, 1, 0, nil
+  MAJOR_VERSION, MINOR_VERSION, TINY_VERSION, PRE_VERSION = 1, 2, 0, nil
   VERSION = [MAJOR_VERSION, MINOR_VERSION, TINY_VERSION, PRE_VERSION].compact.join '.'
 
   # Creates a new Beaver and immediately filters the log files. This should scale well

data/lib/beaver/dam.rb

@@ -31,7 +31,9 @@ module Beaver
   #  :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.
-  #
+  # 
+  #  :tagged => A comma-separated String or Array of Rails Tagged Logger tags. If you specify multiple tags, a request must have *all* of them.
+  # 
   #  :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.
@@ -47,11 +49,11 @@ module Beaver
 
     # 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)
+    def initialize(name, matchers={}, &callback)
       @name = name
       @callback = callback
       @hits = []
-      set_matchers(matchers)
+      build matchers
     end
 
     # Returns an array of IP address that hit this Dam.
@@ -78,12 +80,33 @@ module Beaver
       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
+      if @deep_tag_match
+        return false unless @match_tags.nil? or (@match_tags.any? and request.tags_str and deep_matching_tags(@match_tags, request.tags))
+      else
+        return false unless @match_tags.nil? or (@match_tags.any? and request.tags_str and (@match_tags - request.tags).empty?)
+      end
       return false unless @match_params.nil? or matching_hashes?(@match_params, request.params)
       return true
     end
 
     private
 
+    # Matches tags recursively
+    def deep_matching_tags(matchers, tags)
+      all_tags_matched = nil
+      any_arrays_matched = false
+      for m in matchers
+        if m.is_a? Array
+          matched = deep_matching_tags m, tags
+          any_arrays_matched = true if matched
+        else
+          matched = tags.include? m
+          all_tags_matched = (matched && all_tags_matched != false) ? true : false
+        end
+      end
+      return (all_tags_matched or any_arrays_matched)
+    end
+
     # 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
@@ -107,8 +130,10 @@ module Beaver
       end
     end
 
+    public
+
     # Parses and checks the validity of the matching options passed to the Dam.
-    def set_matchers(matchers)
+    def build(matchers)
       if matchers[:path].respond_to? :===
         @match_path = matchers[:path]
       else
@@ -192,10 +217,34 @@ module Beaver
         else raise ArgumentError, "Params must be a String or a Regexp (it's a #{matchers[:params].class.name})"
       end if matchers[:params]
 
+      if matchers[:tagged]
+        @match_tags = parse_tag_matchers(matchers[:tagged])
+        @deep_tag_match = @match_tags.any? { |t| t.is_a? Array }
+      end
+
       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]
+
+      self
+    end
+
+    private
+
+    # Recursively parses a tag match pattern
+    def parse_tag_matchers(matcher)
+      if matcher.is_a? String
+        matcher.split(',').map { |t| t.strip.downcase }.uniq
+      elsif matcher.is_a? Array
+        matcher.map! do |m|
+          if m.is_a?(Array) or (m.is_a?(String) and m =~ /,/)
+            parse_tag_matchers(m)
+          else m; end
+        end
+      else
+        raise ArgumentError, "tagged must be a String or Array (it's a #{matcher.class.name})"
+      end
     end
   end
 end

data/lib/beaver/parsers/rails.rb

@@ -9,12 +9,14 @@ module Beaver
       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_COMPLETED = /Completed (\d+)/
       REGEX_PATH = /^Started \w{3,4} "([^"]+)"/
-      REGEX_PARAMS_STR = /^  Parameters: (\{.+\})$/
+      REGEX_PARAMS_STR = /  Parameters: (\{.+\})$/
       REGEX_IP = /" for (\d+[\d.]+) at /
       REGEX_FORMAT = /Processing by .+ as (\w+)$/
       REGEX_MS = / in (\d+)ms/
+      REGEX_TAGS = /^(\[.+\] )+/
+      REGEX_TAG = /\[([^\]]+)\] /
       # Depending on the version of Rails, the time format may be wildly different
       REGEX_TIME = / at ([a-z0-9:\+\- ]+)$/i
 
@@ -105,6 +107,26 @@ module Beaver
         m = REGEX_TIME.match(@lines)
         m ? Time.parse(m.captures.first) : nil
       end
+
+      # Parses and returns an array of tags string associated with the request
+      def parse_tags_str
+        t = REGEX_TAGS.match(@lines)
+        t ? t.captures.first : nil
+      end
+
+      # Parses and returns an array of tags associated with the request
+      def parse_tags
+        t = tags_str
+        if t
+          tags = t.scan(REGEX_TAG)
+          tags.flatten!
+          tags.uniq!
+          tags.map! &:downcase
+          tags
+        else
+          []
+        end
+      end
     end
   end
 end

data/lib/beaver/request.rb

@@ -100,6 +100,16 @@ module Beaver
       @time ||= parse_time
     end
 
+    # Returns the tags string associated with the request (e.g. "[tag1] [tag2] ")
+    def tags_str
+      @tags_str ||= parse_tags_str
+    end
+
+    # Returns an array of tags associated with the request
+    def tags
+      @tags ||= parse_tags
+    end
+
     # When called inside of a Beaver::Dam#hit block, this Request will *not* be matched.
     def skip!
       throw :skip
@@ -181,6 +191,16 @@ module Beaver
     def parse_time
       nil
     end
+
+    # Parses and returns the tags string associated with the request (e.g. "[tag1] [tag2] ")
+    def parse_tags_str
+      nil
+    end
+
+    # Parses and returns any tags associated with the request
+    def parse_tags
+      nil
+    end
   end
 
   # Represents a BadRequest that no parser could figure out.

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 1
-  - 1
+  - 2
   - 0
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors: 
 - Jordan Hollinger