request-log-analyzer 1.7.0 → 1.10.0

data/.gitignore

@@ -4,7 +4,10 @@ request-log-analyzer-*.gem
 requests.db
 /pkg
 /doc
+.yardoc/
 /tmp
 /classes
 /files
-/coverage
+/coverage
+Gemfile.lock
+/.bundle/

data/DESIGN.rdoc

@@ -38,4 +38,3 @@ into SQLite database Y. The Summarizer will output its reports.
 
 The output is pushed to a RequestLogAnalyzer::Output object, which takes care of the output.
 It can generate either ASCII, UTF8 or even HTML output.
-

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/README.rdoc

@@ -4,11 +4,11 @@ This is a simple command line tool to analyze request log files in various forma
 
 * Analyzes log files. Currently supports: Amazon S3, Apache, Delayed::Job, Merb, Mysql, PostgreSQL, Rack, Rails and more.
 * Combines multiple files and decompresses compressed files, which comes in handy if you are using logrotate.
-* Uses several metrics, including cumulative request time, mean request time, process blockers, database and rendering time, HTTP methods and statuses, Rails action cache statistics, etc.) (Sample output: http://wiki.github.com/wvanbergen/request-log-analyzer/sample-output)
+* Uses several metrics, including cumulative request time, mean request time, process blockers, database and rendering time, HTTP methods and statuses, Rails action cache statistics, etc.) (Sample output: http://github.com/wvanbergen/request-log-analyzer/wiki/sample-output)
 * Low memory footprint and reasonably fast, so it is safe to run on a production server.
 * MIT licensed
 
-See the project wiki at http://wiki.github.com/wvanbergen/request-log-analyzer for documentation and additional information.
+See the project wiki at http://github.com/wvanbergen/request-log-analyzer/wiki for documentation and additional information.
 
 == Installation & basic usage
 
@@ -22,7 +22,17 @@ request-log-analyzer like this:
 
   $ request-log-analyzer log/production.log
 
-For more details, other file formats, and available command line options, see the project's wiki at http://wiki.github.com/wvanbergen/request-log-analyzer
+For more details, other file formats, and available command line options, see the project's wiki at http://github.com/wvanbergen/request-log-analyzer/wiki
+
+== Benchmarking on different rubies
+
+  $ time ./bin/request-log-analyzer 40MBRailsFile.log
+
+  ruby-1.9.2-p0   15.19s user 0.95s system 99% cpu 16.143 total
+  ruby-1.8.7      25.21s user 1.02s system 99% cpu 26.238 total
+  jruby-1.5.3     32.64s user 4.84s system 99% cpu 37.629 total
+  rbx             46.60s user 2.71s system 108% cpu 45.324 total
+  macruby         75.00s user 20.10s system 110% cpu 1:26.13 total
 
 == Additional information
 
@@ -33,6 +43,7 @@ Do you have a rails application that is not performing as it should? If you need
 an expert to analyze your application, feel free to contact either Willem van
 Bergen (willem@railsdoctors.com) or Bart ten Brinke (bart@railsdoctors.com).
 
-* Project wiki at GitHub: http://wiki.github.com/wvanbergen/request-log-analyzer
+* Project wiki at GitHub: http://github.com/wvanbergen/request-log-analyzer/wiki
+* Issue tracker at GitHub: http://github.com/wvanbergen/request-log-analyzer/issues
 * railsdoctors homepage: http://railsdoctors.com
-* wvanbergen's blog posts: http://techblog.floorplanner.com/tag/request-log-analyzer
+* wvanbergen's blog posts: http://techblog.floorplanner.com/tag/request-log-analyzer

data/bin/request-log-analyzer

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # encoding: utf-8
 
-$:.unshift(File.dirname(__FILE__) + '/../lib')
+$:.unshift(File.expand_path('../lib', File.dirname(__FILE__)))
 require 'request_log_analyzer'
 require 'cli/command_line_arguments'
 require 'cli/progressbar'
@@ -34,6 +34,7 @@ begin
     command_line.option(:file, :alias => :e)
     command_line.option(:mail, :alias => :m)
     command_line.option(:mailhost, :default => 'localhost')
+    command_line.option(:mailsubject)    
     command_line.option(:parse_strategy, :default => 'assume-correct')
     command_line.option(:yaml)
     command_line.option(:dump) # To be deprecated
@@ -85,12 +86,14 @@ rescue CommandLine::Error => e
   puts "  --file <filename>          Redirect output to file."
   puts "  --mail <emailaddress>      Send report to an email address."
   puts "  --mailhost <server>        Use the given server as the SMTP server for sending email."
+  puts "  --mailsubject <text>       Overwrite default mailsubject."
   puts "  --no-progress              Hide the progress bar."
   puts "  --output <format>          Output format. Supports 'html' and 'fixed_width'."
   puts "  --report-width <amount>    Width of ASCII report. Defaults to terminal width."
   puts "  --report-amount <amount>   Maximum numer of results per report."
   puts "  --silent                   Skip the commercials (includes --no-progress)."
   puts "  --yaml <filename>          Dump the results in YAML format in the given file."
+  puts "  --parse-strategy <strategy> Legal values are 'assume-correct' or 'cautious'."
   puts
   puts "Examples:"
   puts "  request-log-analyzer production.log"
@@ -112,7 +115,6 @@ when :console
   require 'cli/database_console'
   DatabaseConsole.new(arguments).run!
 when :strip
-  require File.dirname(__FILE__) + '/../lib/request_log_analyzer/log_processor'
   RequestLogAnalyzer::LogProcessor.build(:strip, arguments).run!
 else
   unless arguments[:silent]

data/lib/cli/database_console_init.rb

@@ -1,5 +1,5 @@
 # Setup the include path
-$:.unshift(File.dirname(__FILE__) + '/..')
+$:.unshift(File.expand_path('..', File.dirname(__FILE__))
 
 $database = RequestLogAnalyzer::Database.new(ENV['RLA_DBCONSOLE_DATABASE'])
 $database.load_database_schema!

data/lib/cli/tools.rb

@@ -34,7 +34,8 @@ def install_rake_tasks(install_type = :rails)
   if install_type.to_sym == :rails
     require 'ftools'
     if File.directory?('./lib/tasks/')
-      File.copy(File.dirname(__FILE__) + '/../../tasks/request_log_analyzer.rake', './lib/tasks/request_log_analyze.rake')
+      task_file = File.expand_path('../../tasks/request_log_analyzer.rake', File.dirname(__FILE__))
+      File.copy(task_file, './lib/tasks/request_log_analyze.rake')
       puts "Installed rake tasks."
       puts "To use, run: rake rla:report"
     else

data/lib/mixins/gets_memory_protection.rb

@@ -29,7 +29,7 @@ class File
     if @last_pos.nil? 
       seek(0, IO::SEEK_END)
       @last_pos = pos
-      seek(0,0)
+      seek(@current_pos, IO::SEEK_SET)
     end
     
     # 

data/lib/request_log_analyzer/aggregator/summarizer.rb

@@ -32,7 +32,7 @@ module RequestLogAnalyzer::Aggregator
       # <tt>optiont</tt> The options to pass to the trackers.
       def track(tracker_klass, value_field = {}, other_options = {})
         options = value_field.kind_of?(Symbol) ? other_options.merge(:value => value_field) : value_field.merge(other_options) 
-        tracker_klass = RequestLogAnalyzer::Tracker.const_get(RequestLogAnalyzer::to_camelcase(tracker_klass)) if tracker_klass.kind_of?(Symbol)
+        tracker_klass = RequestLogAnalyzer::Tracker.const_get(RequestLogAnalyzer.to_camelcase(tracker_klass)) if tracker_klass.kind_of?(Symbol)
         @trackers << tracker_klass.new(options)
       end
     end
@@ -85,7 +85,7 @@ module RequestLogAnalyzer::Aggregator
       trackers_export = @trackers.inject({}) do |export, tracker|
         export[tracker.title] = tracker.to_yaml_object; export
       end
-      YAML::dump(trackers_export)
+      YAML.dump(trackers_export)
     end
 
     # Call report on all trackers.

data/lib/request_log_analyzer/aggregator.rb

@@ -1,8 +1,8 @@
 module RequestLogAnalyzer::Aggregator
 
-  def self.const_missing(const)
-    RequestLogAnalyzer::load_default_class_file(self, const)
-  end
+  autoload :Echo,             'request_log_analyzer/aggregator/echo'
+  autoload :Summarizer,       'request_log_analyzer/aggregator/summarizer'
+  autoload :DatabaseInserter, 'request_log_analyzer/aggregator/database_inserter'
 
   # The base class of an aggregator. This class provides the interface to which
   # every aggregator should comply (by simply subclassing this class).

data/lib/request_log_analyzer/controller.rb

@@ -20,11 +20,11 @@ module RequestLogAnalyzer
     # Builds a RequestLogAnalyzer::Controller given parsed command line arguments
     # <tt>arguments<tt> A CommandLine::Arguments hash containing parsed commandline parameters.
     def self.build_from_arguments(arguments)
-      
-      require 'lib/mixins/gets_memory_protection' if arguments[:gets_memory_protection]
-      
+
+      require 'mixins/gets_memory_protection' if arguments[:gets_memory_protection]
+
       options = {}
-      
+
       # Copy fields
       options[:database]       = arguments[:database]
       options[:reset_database] = arguments[:reset_database]
@@ -33,7 +33,7 @@ module RequestLogAnalyzer
       options[:mail]           = arguments[:mail]
       options[:no_progress]    = arguments[:no_progress]
       options[:format]         = arguments[:format]
-      options[:output]         = arguments[:output].downcase
+      options[:output]         = arguments[:output]
       options[:file]           = arguments[:file]
       options[:after]          = arguments[:after]
       options[:before]         = arguments[:before]
@@ -44,23 +44,25 @@ module RequestLogAnalyzer
       options[:report_width]   = arguments[:report_width]
       options[:report_sort]    = arguments[:report_sort]
       options[:report_amount]  = arguments[:report_amount]
-      options[:mailhost]       = arguments[:mailhost] 
-      options[:silent]         = arguments[:silent] 
-      
+      options[:mailhost]       = arguments[:mailhost]
+      options[:mailsubject]    = arguments[:mailsubject]
+      options[:silent]         = arguments[:silent]
+      options[:parse_strategy] = arguments[:parse_strategy]
+
       # Apache format workaround
       if arguments[:rails_format]
         options[:format] = {:rails => arguments[:rails_format]}
       elsif arguments[:apache_format]
         options[:format] = {:apache => arguments[:apache_format]}
       end
-      
+
       # Handle output format casing
       if options[:output].class == String
         options[:output] = 'FancyHTML'  if options[:output] =~ /^fancy_?html$/i
         options[:output] = 'HTML'       if options[:output] =~ /^html$/i
         options[:output] = 'FixedWidth' if options[:output] =~ /^fixed_?width$/i
       end
-      
+
       # Register sources
       if arguments.parameters.length == 1
         file = arguments.parameters[0]
@@ -75,7 +77,7 @@ module RequestLogAnalyzer
       else
         options.store(:source_files, arguments.parameters)
       end
-      
+
       # Guess file format
       if !options[:format] && options[:source_files]
         options[:format] = :rails # Default
@@ -89,7 +91,7 @@ module RequestLogAnalyzer
           end
         end
       end
-      
+
       build(options)
     end
 
@@ -107,6 +109,7 @@ module RequestLogAnalyzer
     # * <tt>:format</tt> :rails, {:apache => 'FORMATSTRING'}, :merb, :amazon_s3, :mysql or RequestLogAnalyzer::FileFormat class. (Defaults to :rails).
     # * <tt>:mail</tt> Email the results to this email address.
     # * <tt>:mailhost</tt> Email the results to this mail server.
+    # * <tt>:mailsubject</tt> Email subject.
     # * <tt>:no_progress</tt> Do not display the progress bar (increases parsing speed).
     # * <tt>:output</tt> 'FixedWidth', 'HTML' or RequestLogAnalyzer::Output class. Defaults to 'FixedWidth'.
     # * <tt>:reject</tt> Reject specific {:field => :value} combination (expects a single hash).
@@ -121,7 +124,7 @@ module RequestLogAnalyzer
     # RequestLogAnalyzer::Controller.build(
     #   :output       => :HTML,
     #   :mail         => 'root@localhost',
-    #   :after        => Time.now - 24*60*60, 
+    #   :after        => Time.now - 24*60*60,
     #   :source_files => '/var/log/passenger.log'
     # ).run!
     #
@@ -138,57 +141,60 @@ module RequestLogAnalyzer
       options[:report_sort]   ||= 'sum,mean'
       options[:boring]        ||= false
       options[:silent]        ||= false
-      
+
       options[:no_progress] = true if options[:silent]
-      
+
       # Deprecation warnings
       if options[:dump]
         warn "[DEPRECATION] `:dump` is deprecated.  Please use `:yaml` instead."
         options[:yaml]          = options[:dump]
       end
-      
+
       # Set the output class
       output_args   = {}
       output_object = nil
       if options[:output].is_a?(Class)
         output_class = options[:output]
       else
-        output_class = RequestLogAnalyzer::Output::const_get(options[:output])
+        output_class = RequestLogAnalyzer::Output.const_get(options[:output])
       end
-      
+
       output_sort   = options[:report_sort].split(',').map { |s| s.to_sym }
       output_amount = options[:report_amount] == 'all' ? :all : options[:report_amount].to_i
-      
+
       if options[:file]
         output_object = %w[File StringIO].include?(options[:file].class.name) ? options[:file] : File.new(options[:file], "w+")
         output_args   = {:width => 80, :color => false, :characters => :ascii, :sort => output_sort, :amount => output_amount }
       elsif options[:mail]
-        output_object = RequestLogAnalyzer::Mailer.new(options[:mail], options[:mailhost])
+        output_object = RequestLogAnalyzer::Mailer.new(options[:mail], options[:mailhost], :subject => options[:mailsubject])
         output_args   = {:width => 80, :color => false, :characters => :ascii, :sort => output_sort, :amount => output_amount  }
       else
         output_object = STDOUT
         output_args   = {:width => options[:report_width].to_i, :color => !options[:boring],
                         :characters => (options[:boring] ? :ascii : :utf), :sort => output_sort, :amount => output_amount }
       end
-      
+
       output_instance = output_class.new(output_object, output_args)
-      
+
       # Create the controller with the correct file format
       if options[:format].kind_of?(Hash)
         file_format = RequestLogAnalyzer::FileFormat.load(options[:format].keys[0], options[:format].values[0])
       else
         file_format = RequestLogAnalyzer::FileFormat.load(options[:format])
       end
-      
+
       # Kickstart the controller
-      controller = Controller.new(  RequestLogAnalyzer::Source::LogParser.new(file_format, :source_files => options[:source_files]),
-                                    { :output => output_instance,
-                                      :database => options[:database],                # FUGLY!
-                                      :yaml => options[:yaml], 
-                                      :reset_database => options[:reset_database],
-                                      :no_progress => options[:no_progress], 
-                                      :silent => options[:silent],
-                                    })
+      controller =
+        Controller.new(RequestLogAnalyzer::Source::LogParser.new(file_format,
+                                                                 :source_files => options[:source_files],
+                                                                 :parse_strategy => options[:parse_strategy]),
+                       { :output         => output_instance,
+                         :database       => options[:database],                # FUGLY!
+                         :yaml           => options[:yaml],
+                         :reset_database => options[:reset_database],
+                         :no_progress    => options[:no_progress],
+                         :silent         => options[:silent]
+                       })
 
       # register filters
       if options[:after] || options[:before]
@@ -210,7 +216,7 @@ module RequestLogAnalyzer
         end
       end
 
-      if options[:reject]
+      if options[:select]
         options[:select].each do |(field, value)|
           controller.add_filter(:field, :mode => :select, :field => field, :value => value)
         end
@@ -224,7 +230,7 @@ module RequestLogAnalyzer
 
       file_format.setup_environment(controller)
       return controller
-    end  
+    end
 
     # Builds a new Controller for the given log file format.
     # <tt>format</tt> Logfile format. Defaults to :rails
@@ -242,7 +248,7 @@ module RequestLogAnalyzer
       @filters     = []
       @output      = options[:output]
       @interrupted = false
-      
+
       # Register the request format for this session after checking its validity
       raise "Invalid file format!" unless @source.file_format.valid?
 
@@ -281,7 +287,7 @@ module RequestLogAnalyzer
     # Adds an aggregator to the controller. The aggregator will be called for every request
     # that is parsed from the provided sources (see add_source)
     def add_aggregator(agg)
-      agg = RequestLogAnalyzer::Aggregator.const_get(RequestLogAnalyzer::to_camelcase(agg)) if agg.kind_of?(Symbol)
+      agg = RequestLogAnalyzer::Aggregator.const_get(RequestLogAnalyzer.to_camelcase(agg)) if agg.kind_of?(Symbol)
       @aggregators << agg.new(@source, @options)
     end
 
@@ -289,7 +295,7 @@ module RequestLogAnalyzer
 
     # Adds a request filter to the controller.
     def add_filter(filter, filter_options = {})
-      filter = RequestLogAnalyzer::Filter.const_get(RequestLogAnalyzer::to_camelcase(filter)) if filter.kind_of?(Symbol)
+      filter = RequestLogAnalyzer::Filter.const_get(RequestLogAnalyzer.to_camelcase(filter)) if filter.kind_of?(Symbol)
       @filters << filter.new(source.file_format, @options.merge(filter_options))
     end
 

data/lib/request_log_analyzer/database.rb

@@ -3,9 +3,11 @@ require 'active_record'
 
 class RequestLogAnalyzer::Database
 
-  def self.const_missing(const) # :nodoc:
-    RequestLogAnalyzer::load_default_class_file(self, const)
-  end
+  autoload :Connection, 'request_log_analyzer/database/connection'
+  autoload :Base,       'request_log_analyzer/database/base'
+  autoload :Request,    'request_log_analyzer/database/request'
+  autoload :Source,     'request_log_analyzer/database/source'
+  autoload :Warning,    'request_log_analyzer/database/warning'
 
   include RequestLogAnalyzer::Database::Connection
 

data/lib/request_log_analyzer/file_format/apache.rb

@@ -30,20 +30,23 @@ module RequestLogAnalyzer::FileFormat
 
     # A hash that defines how the log format directives should be parsed.
     LOG_DIRECTIVES = {
-      '%' => { :regexp => '%', :captures => [] },
-      'h' => { :regexp => '([A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+)',  :captures => [{:name => :remote_host, :type => :string}] },
-      'a' => { :regexp => "(#{ip_address})", :captures => [{:name => :remote_ip, :type => :string}] },
-      'b' => { :regexp => '(\d+|-)', :captures => [{:name => :bytes_sent, :type => :traffic}] },
-      'c' => { :regexp => '(\+|\-|\X)', :captures => [{:name => :connection_status, :type => :integer}] },
-      'D' => { :regexp => '(\d+|-)', :captures => [{:name => :duration, :type => :duration, :unit => :musec}] },
-      'l' => { :regexp => '([\w-]+)', :captures => [{:name => :remote_logname, :type => :nillable_string}] },
-      'T' => { :regexp => '((?:\d+(?:\.\d+))|-)', :captures => [{:name => :duration, :type => :duration, :unit => :sec}] },
-      't' => { :regexp => "\\[(#{APACHE_TIMESTAMP})?\\]", :captures => [{:name => :timestamp, :type => :timestamp}] },
-      's' => { :regexp => '(\d{3})', :captures => [{:name => :http_status, :type => :integer}] },
-      'u' => { :regexp => '(\w+|-)', :captures => [{:name => :user, :type => :nillable_string}] },
-      'U' => { :regexp => '(\/\S*)', :captures => [{:name => :path, :type => :string}] },
-      'r' => { :regexp => '([A-Z]+) (\S+) HTTP\/(\d+(?:\.\d+)*)', :captures => [{:name => :http_method, :type => :string},
-                       {:name => :path, :type => :path}, {:name => :http_version, :type => :string}]},
+      '%' => { nil => { :regexp => '%', :captures => [] } },
+      'h' => { nil => { :regexp => '([A-Za-z0-9-]+(?:\.[A-Za-z0-9-]+)+)',  :captures => [{:name => :remote_host, :type => :string}] } },
+      'a' => { nil => { :regexp => "(#{ip_address})", :captures => [{:name => :remote_ip, :type => :string}] } },
+      'b' => { nil => { :regexp => '(\d+|-)', :captures => [{:name => :bytes_sent, :type => :traffic}] } },
+      'c' => { nil => { :regexp => '(\+|\-|\X)', :captures => [{:name => :connection_status, :type => :integer}] } },
+      'D' => { nil     => { :regexp => '(\d+|-)', :captures => [ {:name => :duration, :type => :duration, :unit => :musec }] },
+               'micro' => { :regexp => '(\d+|-)', :captures => [ {:name => :duration, :type => :duration, :unit => :musec }] },
+               'milli' => { :regexp => '(\d+|-)', :captures => [ {:name => :duration, :type => :duration, :unit => :msec }] }
+             },
+      'l' => { nil => { :regexp => '([\w-]+)', :captures => [{:name => :remote_logname, :type => :nillable_string}] } },
+      'T' => { nil => { :regexp => '((?:\d+(?:\.\d+))|-)', :captures => [{:name => :duration, :type => :duration, :unit => :sec}] } },
+      't' => { nil => { :regexp => "\\[(#{APACHE_TIMESTAMP})?\\]", :captures => [{:name => :timestamp, :type => :timestamp}] } },
+      's' => { nil => { :regexp => '(\d{3})', :captures => [{:name => :http_status, :type => :integer}] } },
+      'u' => { nil => { :regexp => '(\w+|-)', :captures => [{:name => :user, :type => :nillable_string}] } },
+      'U' => { nil => { :regexp => '(\/\S*)', :captures => [{:name => :path, :type => :string}] } },
+      'r' => { nil => { :regexp => '([A-Z]+) (\S+) HTTP\/(\d+(?:\.\d+)*)', :captures => [{:name => :http_method, :type => :string},
+                       {:name => :path, :type => :path}, {:name => :http_version, :type => :string}]} },
       'i' => { 'Referer'    => { :regexp => '(\S+)', :captures => [{:name => :referer, :type => :nillable_string}] },
                'User-agent' => { :regexp => '(.*)',  :captures => [{:name => :user_agent, :type => :user_agent}] }
              }
@@ -72,14 +75,13 @@ module RequestLogAnalyzer::FileFormat
 
         if variable
           # Check if we recognize the log directive
-          directive = LOG_DIRECTIVES[variable]
-          directive = directive[arg] if directive && arg
+          directive = LOG_DIRECTIVES[variable][arg] rescue nil
 
           if directive
             line_regexp << directive[:regexp]   # Parse the value of the directive
             captures    += directive[:captures] # Add the directive's information to the captures
           else
-            puts "%#{directive} log directiven not yet supported, field is ignored."
+            puts "Apache log directive %#{arg}#{variable} is not yet supported by RLA, the field will be ignored."
             line_regexp << '.*' # Just accept any input for this literal
           end
         end
@@ -126,22 +128,11 @@ module RequestLogAnalyzer::FileFormat
         "#{value[7,4]}#{MONTHS[value[3,3]]}#{value[0,2]}#{value[12,2]}#{value[15,2]}#{value[18,2]}".to_i
       end
 
-      # This function can be overridden to rewrite the path for better categorization in the
-      # reports.
-      def convert_path(value, definition)
-        value
-      end
-
       # This function can be overridden to simplify the user agent string for better
       # categorization in the reports
       def convert_user_agent(value, definition)
         value # TODO
       end
-
-      # Make sure that the string '-' is parsed as a nil value.
-      def convert_nillable_string(value, definition)
-        value == '-' ? nil : value
-      end
     end
   end
 end

data/lib/request_log_analyzer/file_format/delayed_job2.rb

@@ -0,0 +1,38 @@
+module RequestLogAnalyzer::FileFormat
+
+  # The DelayedJob2 file format parsed log files that are created by DelayedJob 2.0.
+  # By default, the log file can be found in RAILS_ROOT/log/delayed_job.log
+  class DelayedJob2 < Base
+    
+    extend CommonRegularExpressions
+    
+    line_definition :job_lock do |line|
+      line.header = true
+      line.regexp = /(#{timestamp('%Y-%m-%dT%H:%M:%S%z')}): \* \[Worker\(\S+ host:(\S+) pid:(\d+)\)\] acquired lock on (\S+)/
+      
+      line.capture(:timestamp).as(:timestamp)
+      line.capture(:host)
+      line.capture(:pid).as(:integer)
+      line.capture(:job)
+    end
+    
+    line_definition :job_completed do |line|
+      line.footer = true
+      line.regexp = /(#{timestamp('%Y-%m-%dT%H:%M:%S%z')}): \* \[JOB\] \S+ host:(\S+) pid:(\d+) completed after (\d+\.\d+)/
+      line.capture(:timestamp).as(:timestamp)
+      line.capture(:host)
+      line.capture(:pid).as(:integer)
+      line.capture(:duration).as(:duration, :unit => :sec)
+    end
+    
+    report do |analyze|
+      analyze.timespan
+      analyze.hourly_spread
+
+      analyze.frequency :job, :line_type => :job_completed, :title => "Completed jobs"
+      #analyze.frequency :job, :if => lambda { |request| request[:attempts] ==  1 }, :title => "Failed jobs"
+      
+      analyze.duration :duration, :category => :job, :line_type => :job_completed, :title => "Job duration"
+    end
+  end
+end

data/lib/request_log_analyzer/file_format/delayed_job21.rb

@@ -0,0 +1,39 @@
+module RequestLogAnalyzer::FileFormat
+
+  # The DelayedJob21 file format parsed log files that are created by DelayedJob 2.1 or higher.
+  # By default, the log file can be found in RAILS_ROOT/log/delayed_job.log
+  class DelayedJob21 < Base
+    
+    extend CommonRegularExpressions
+    
+    line_definition :job_lock do |line|
+      line.header = true
+      line.regexp = /(#{timestamp('%Y-%m-%dT%H:%M:%S%z')}): \[Worker\(\S+ host:(\S+) pid:(\d+)\)\] acquired lock on (\S+)/
+      
+      line.capture(:timestamp).as(:timestamp)
+      line.capture(:host)
+      line.capture(:pid).as(:integer)
+      line.capture(:job)
+    end
+    
+    line_definition :job_completed do |line|
+      line.footer = true
+      line.regexp = /(#{timestamp('%Y-%m-%dT%H:%M:%S%z')}): \[Worker\(\S+ host:(\S+) pid:(\d+)\)\] (\S+) completed after (\d+\.\d+)/
+      line.capture(:timestamp).as(:timestamp)
+      line.capture(:host)
+      line.capture(:pid).as(:integer)
+      line.capture(:job)
+      line.capture(:duration).as(:duration, :unit => :sec)
+    end
+    
+    report do |analyze|
+      analyze.timespan
+      analyze.hourly_spread
+
+      analyze.frequency :job, :line_type => :job_completed, :title => "Completed jobs"
+      #analyze.frequency :job, :if => lambda { |request| request[:attempts] ==  1 }, :title => "Failed jobs"
+      
+      analyze.duration :duration, :category => :job, :line_type => :job_completed, :title => "Job duration"
+    end
+  end
+end