apache_log_report 0.9.0 → 0.9.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 911c11b89b21140783332a66419e442ed366debad950a430af6265a5cc800129
-  data.tar.gz: 0f4d3bf245a2436412d7419d724c0c996d7ea0c6057a847f24cde376e6cf13c5
+  metadata.gz: 8d75b1094318f7610f0ef9f0cd34ef7fe5d2ba38effb65514d1ca2dddb90962c
+  data.tar.gz: c0c16a44463d9a808dd6919aaf8aa1c1dfbf16bd589bdef1c8ab6e839dba8c05
 SHA512:
-  metadata.gz: eed37e0f7c2098e2ca6192760ca5c9722ada8c0a5259d3c52fd9ae382b32a0d39f3da3e37bbcc9ab2446d92e35c3b538c1037ac48a4364f8d05ec2c58ab54fac
-  data.tar.gz: 563e8a68028d905bd8389ceefff7ed02cdb82715426fa1e2d5b47feeb471d75034e59b948a04899801e6d7b708f0dca7ff385111d163aef273b91f5c8e3bf2f4
+  metadata.gz: af73bf2dd1eec2b9985cc0fa0cf72c7ae1ca0afa91e14eb11e5b6e187d52a81880fe4b3051eba23ad3d5b207d977e0a9132e0644ae51853b8e6d76ff41b7ee1d
+  data.tar.gz: c968b4971563a5164e790392a34d7cda4787a21385f283d6f39c27ae14a4b10bb99c735d7084f562af169337f77e17e22b4a78d7e9cd9d84eca411be0d59b491

data/README.org

@@ -12,6 +12,13 @@
 
 See the [[file:CHANGELOG.org][CHANGELOG]] file.
 
+* Todo
+
+** TODO Version information from command line and in reports
+** TODO Refactor code from one giant class to more manageable chunkes
+** TODO Move performance stats var to class (to isolate vars)
+** TODO Check total number of days (which is not working, now)
+
 * Compatibility
 
 

data/apache_log_report.gemspec

@@ -27,6 +27,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "apache_log-parser"
   spec.add_dependency "browser"
   spec.add_dependency "sqlite3"
+  spec.add_dependency "terminal-table"
 end

data/exe/apache_log_report

@@ -1,627 +1,31 @@
 #!/usr/bin/env ruby
 
-require 'apache_log_report'
-require 'progressbar'
-
-LIMIT  = 30
-
-##############################################################################
-# MONKEY PATCH ARRAY AND HASH TO BUILD PIPES WHEN COMPUTING STATS
-
-class Array
-  # counts occurrences of each element in an array and returns a hash { element => count }
-  def uniq_with_count
-    h = Hash.new(0); self.each { |l| h[l] += 1 }; h
-  end
-end
-
-class Hash
-  # sort and limit entries of a hash. Returns an array which can be output
-  # sort by key or value, optionally reverse, optionally return a limited number of items
-  # {2014 => 10, 2015 => 20, 2010 => 30} => [[2014, 10], ...]
-  def prepare_for_output options = {}
-    sorted_a = []
-
-    if options[:sort] == :key
-      sorted_a = self.sort_by { |k, v| k }
-    elsif options[:sort]
-      sorted_a = self.sort_by { |k, v| v[options[:sort]] }
-    else
-      sorted_a = self.to_a
-    end
-
-    sorted_a = sorted_a.reverse if options[:reverse]
-    sorted_a = sorted_a[0, options[:limit]] if options[:limit]
-
-    sorted_a
-  end
-end
-
-##############################################################################
-# EMITTERS ARE USED TO OUTPUT TO DIFFERENT FORMATS
-
-class OrgTableEmitter
-  # print either of:
-  # [[ row_title, value, value, value, ...], ...]
-  # [[ row_title, {key: value, key: value, key: value}, ...], ...]
-  def self.emit table, options = {}
-    if table.size == 0
-      puts "No values to show"
-      return
-    end
-
-    puts "\n\n#{options[:title]}\n\n" if options[:title]
-
-    puts "#+NAME: #{options[:name]}" if options[:name]
-
-    # if table is in the form of a hash, transform it into an array
-    if table[0][1].class == Hash then
-      table = table.map { |x| [ x[0] ] + x[1].values }
-    end
-
-    # get longest row title and then longest column or use 50 and 10 as defaults
-    firstcol_length = options[:compact] ? 2 + table.map { |x| x[0].to_s.size }.max : 50
-    othercol_length = options[:compact] ? 2 + table.map { |x| x[1..-1].map { |x| x.to_s.size }.max }.max : 10
-    # take into account also the headers lengths'
-    headers_length = options[:headers] ? 2 + options[:headers][1..-1].map { |x| x.to_s.size }.max : 0
-    othercol_length = [othercol_length, headers_length].max
-
-    # build the formatting string
-    col_sizes = [ firstcol_length ] + [othercol_length] * table[0][1..-1].size
-    col_classes = table[0].map { |x| x.class.to_s }
-    col_formats = col_classes.each_with_index.map { |x, i| format_for(x, col_sizes[i]) }.join("") + "|"
-
-    # print header if asked to do so
-    if options[:headers]
-      puts (col_sizes.map { |x| "| %-#{x}s " }.join("") % options[:headers]) + "|"
-      puts (col_sizes.map { |x| "|#{"-" * (2 + x)}" }.join("")) + "|"
-    end
-
-    # print each table row
-    table.each do |row|
-      puts col_formats % row
-    end
-
-    puts "\n"
-  end
-
-  private 
-
-  def self.format_for klass, size
-    case klass
-    when "String"
-      "| %-#{size}s "
-    when "Integer"
-      "| %#{size}d "
-    when "Double"
-      "| %#{size}.2f "
-    when "Float"
-      "| %#{size}.2f "
-    else
-      "| %#{size}s "
-    end      
-  end
-
-end
-
-
-##############################################################################
-# PARSE OPTIONS
-
-
-##############################################################################
-# PARSE COMMAND LINE, SETS OPTIONS, PERFORM BASIC CHECKS, AND RUN
-
-def days log
-  (log.last[:date_time].to_date - log.first[:date_time].to_date).to_i
-end
-
-options = OptionParser.parse ARGV
-
-limit = options[:limit]
-from_date = options[:from_date]
-to_date = options[:to_date]
-
-ignore_crawlers = options[:ignore_crawlers]
-only_crawlers = options[:only_crawlers]
-distinguish_crawlers = options[:distinguish_crawlers]
-
-no_selfpoll = options[:no_selfpoll] 
-prefix = options[:prefix] ? "#{options[:prefix]}" : ""
-suffix = options[:suffix] ? "#{options[:suffix]}" : ""
-log_file = ARGV[0]
-
-
-if log_file and not File.exist? log_file
-  puts "Error: file #{log_file} does not exist"
-  exit 1
-end
-
-##############################################################################
-# COMPUTE THE STATISTICS
-
-started_at = Time.now
-log = LogParser.parse log_file, options
-days = days(log)
-
-log_no_selfpolls = log.select { |x| x[:ip] != "::1" }
-
-log_input = no_selfpoll ? log : log_no_selfpolls
-
-# get only requested entries
-log_filtered = log_input.select { |x|
-  (not from_date or from_date <= x[:date_time]) and
-    (not to_date or x[:date_time] <= to_date) and
-    (not ignore_crawlers or x[:bot] == false) and
-    (not only_crawlers or x[:bot] == true)
-}
-days_filtered = days(log_filtered)
-
-printf <<EOS
-#+TITLE: Apache Log Analysis: #{log_file}
-#+DATE: <#{Date.today}>
-#+STARTUP: showall
-#+OPTIONS: ^:{}
-#+HTML_HEAD: <link rel="stylesheet" type="text/css" href="ala-style.css" />
-#+OPTIONS: html-style:nil
-EOS
-
-puts "\n\n* Summary"
-
-OrgTableEmitter.emit [ ["Input file", log_file || "stdin"],
-                       ["Ignore crawlers", options[:ignore_crawlers] == true],
-                       ["Only crawlers", options[:only_crawlers] == true],
-                       ["Distinguish crawlers", options[:distinguish_crawlers] == true],
-                       ["No selfpoll", no_selfpoll],
-                       ["Filter by date", (options[:from_date] != nil or options[:to_date] != nil)],
-                       ["Prefix", prefix],
-                       ["Suffix", suffix]
-                     ],
-                     title: "** Log Analysis Request Summary",
-                     compact: true
-
-
-OrgTableEmitter.emit [ ["First request", log.first[:date_time]],
-                       ["Last request", log.last[:date_time]],
-                       ["Days", days.to_s]
-                     ],
-                     title: "** Logging Period",
-                     compact: true
-
-
-OrgTableEmitter.emit [ ["First day (filtered)", log_filtered.first[:date_time]],
-                       ["Last day (filtered)", log_filtered.last[:date_time]],
-                       ["Days (filtered)", days_filtered.to_s]
-                     ],
-                     title: "** Portion Analyzed",
-                     compact: true
-
-
-OrgTableEmitter.emit [ ["Log size", log.size],
-                       ["Self poll entries", log.size - log_no_selfpolls.size],
-                       ["Entries Parsed", log_input.size],
-                       ["Entries after filtering", log_filtered.size],
-                     ],
-                     title: "** Filtering",
-                     compact: true,
-                     name: "size"
-
-#
-# hits, unique visitors, and size per day
-# take an array of hashes, group by a lambda function, count hits, visitors, and tx data
-#
-def group_and_count log, key
-  matches = log.group_by { |x| key.call(x) }
-
-  h = {}
-
-  # each key in matches is an array of hashes (all log entries matching key)
-  matches.each do |k, v|
-    h[k] = {
-      hits: v.size,
-      visitors: v.uniq { |x| [ x[:date_time].to_date, x[:ip], x[:user_agent_string] ] }.count,
-      tx: v.map { |x| x[:size] }.inject(&:+) / 1024,
-    }
-  end
-
-  h
-end
-
-# like the previous function, but the count function is responsible of returning a hash with the desired data
-# the previous function is: group_and_generic_count log, key, lamnda { |v| { hits: v.size, visitors: v.uniq ..., tx: v.map ... } }
-def group_and_generic_count log, key, count
-  matches = log.group_by { |x| key.call(x) }
-
-  h = {}
-
-  # each key in matches is an array of hashes (all log entries matching key)
-  matches.each do |k, v|
-    h[k] = count.call(v)
-  end
-
-  h
-end
-
-
-def totals hash
-  h = Hash.new
-  [:hits, :visitors, :tx].each do |c|
-    h[c] = hash.values.map { |x| x[c] }.inject(&:+)
-  end
-  h
-end
-
-##############################################################################
-
-table = group_and_count log_filtered, lambda { |x| x[:date_time].to_date }
-totals = totals table
-
-OrgTableEmitter.emit [ ["Hits", totals[:hits]],
-                       ["Unique Visitors", totals[:visitors]],
-                       ["Hits / Unique Visitor", totals[:hits] / totals[:visitors].to_f],
-                       ["TX (Kb)", totals[:tx] ],
-                       ["TX (Kb) / Unique Visitor", totals[:tx] / totals[:visitors]],
-                     ],
-                     title: "* Totals",
-                     name: "totals",
-                     compact: true
-
-if (distinguish_crawlers)
-  bot_table = group_and_count log_filtered.select { |x| x[:bot] }, lambda { |x| x[:date_time].to_date }
-  bot_totals = totals bot_table
-
-  OrgTableEmitter.emit [ ["Hits", bot_totals[:hits]],
-                         ["Unique Visitors", bot_totals[:visitors]],
-                         ["Hits / Unique Visitor", bot_totals[:hits] / bot_totals[:visitors].to_f],
-                         ["TX (Kb)", bot_totals[:tx] ],
-                         ["TX (Kb) / Unique Visitor", bot_totals[:tx] / bot_totals[:visitors]],
-                       ],
-                       title: "** Bot Totals",
-                       name: "bot_totals",
-                       compact: true
-
-  vis_table = group_and_count log_filtered.select { |x| not x[:bot] }, lambda { |x| x[:date_time].to_date }
-  vis_totals = totals vis_table
-
-  OrgTableEmitter.emit [ ["Hits", vis_totals[:hits]],
-                         ["Unique Visitors", vis_totals[:visitors]],
-                         ["Hits / Unique Visitor", vis_totals[:hits] / vis_totals[:visitors].to_f],
-                         ["TX (Kb)", vis_totals[:tx] ],
-                         ["TX (Kb) / Unique Visitor", vis_totals[:tx] / vis_totals[:visitors]],
-                       ],
-                       title: "** Visitors Totals",
-                       name: "vis_totals",
-                       compact: true
-
-end
-
-enriched_table = Hash.new
-table.map { |k, v| enriched_table[k] = v.merge({ dow: k.wday, month: k.month }) }
-
-OrgTableEmitter.emit enriched_table.prepare_for_output(sort: :key),
-                     title: "* Daily Distribution",
-                     compact: true,
-                     headers: ["Day", "Hits", "Visitors", "Size", "Wday", "Month"],
-                     name: "daily_distribution"
-
-puts <<EOS
-#+BEGIN_SRC gnuplot :var data = daily_distribution :results output :exports both :file #{prefix}daily#{suffix}.svg
-reset 
-set grid ytics linestyle 0
-set grid xtics linestyle 0
-set terminal svg size 1200,800 fname 'Arial'
-
-set xdata time
-set timefmt "%Y-%m-%d"
-set format x "%a, %b %d"
-set xtics rotate by 60 right
-
-set title "Hits and Visitors"
-set xlabel "Date"
-set ylabel "Hits"
-set ylabel2 "Visits"
-
-set style fill transparent solid 0.2 noborder
-
-plot data using 1:2 with linespoints lw 3 lc rgb "#0000AA" pointtype 5 title "Hits" axes x1y2,     \\
-     data using 1:2 with filledcurves below x1 linecolor rgb "#0000AA" notitle axes x1y2, \\
-     data using 1:3 with linespoints lw 3 lc rgb "#AA0000" pointtype 7 title "Visitors", \\
-     data using 1:3 with filledcurves below x1 notitle linecolor rgb "#AA0000", \\
-     data using 1:($3+10):3 with labels notitle textcolor rgb "#AA0000", \\
-     data using 1:($2+100):2 with labels notitle textcolor rgb "#0000AA" axes x1y2
-#+END_SRC
-EOS
-
-#
-# distribution per hour
-#
-
-table = group_and_count log_filtered, lambda { |x| x[:date_time].hour }
-table_processed = table.prepare_for_output(sort: :key).map { |x|
-  ["%02d" % x[0] + ":00"] +
-    [ x[1].merge(hits_per_day: x[1][:hits] / days_filtered,
-                 visitors_per_day: x[1][:visitors] / days_filtered,
-                 tx_per_day: x[1][:tx] / days_filtered) ] }
-
-OrgTableEmitter.emit table_processed,
-                     title: "* Time Distribution",
-                     compact: true,
-                     headers: ["Time", "Hits", "Visitors", "Size (Kb)", "Hits/Day", "Visit/Day", "Size (Kb)/Day"],
-                     name: "time_distribution"
-
-puts <<EOS
-#+BEGIN_SRC gnuplot :var data = time_distribution :results output :exports both :file #{prefix}time#{suffix}.svg
-reset 
-set terminal svg size 1200,800 fname 'Arial' fsize 10
-
-set grid ytics linestyle 0
-
-set title "Hits and Visitors"
-set xlabel "Date"
-set ylabel "Hits and Visits"
-
-set style fill solid 0.25
-set boxwidth 0.6
-
-set style data histograms
-set style histogram clustered gap 1
-
-plot data using 2:xtic(1) lc rgb "#0000AA" title "Hits",     \\
-     data using 3 lc rgb "#AA0000" title "Visitors" axes x1y2, \\
-     data using ($0 - 0.2):($2 + 10):2 with labels title "" textcolor rgb("#0000AA"), \\
-     data using ($0 + 0.2):($3 + 10):3 with labels title "" textcolor rgb("#AA0000") axes x1y2
-#+END_SRC
-
-EOS
-
-puts <<EOS
-#+BEGIN_SRC gnuplot :var data = time_distribution :results output :exports both :file #{prefix}time-traffic#{suffix}.svg
-reset 
-set terminal svg size 1200,800 fname 'Arial' fsize 10
-
-set grid ytics linestyle 0
-
-set title "Traffic"
-set xlabel "Date"
-set ylabel "Traffic"
-
-set style fill solid 0.50
-set boxwidth 0.6
-
-set style data histograms
-set style histogram clustered gap 1
-
-plot data using 2:xtic(1) lc rgb "#00AA00" title "Traffic", \\
-     data using ($0):($2 + 10):2 with labels title "" textcolor rgb("#00AA00")
-#+END_SRC
-
-EOS
-
-#
-# most requested pages
-#
-
-log_success = log_filtered.select { |x| (x[:status][0] == "2" or x[:status][0] == "3") and x[:type] == ".html" }
-table = group_and_count log_success, lambda { |x| x[:uri] }
-
-OrgTableEmitter.emit table.prepare_for_output(sort: :hits, reverse: true, limit: limit),
-                     title: "* Most Requested Pages",
-                     compact: true,
-                     headers: ["Page", "Hits", "Visitors", "Size"],
-                     name: "pages"
-
-puts "Total of #{table.size} entries."
-
-#
-# most requested URIs
-#
-
-log_success = log_filtered.select { |x| (x[:status][0] == "2" or x[:status][0] == "3") and x[:type] != ".html" }
-table = group_and_count log_success, lambda { |x| x[:uri] }
-
-OrgTableEmitter.emit table.prepare_for_output(sort: :hits, reverse: true, limit: limit),
-                     title: "* Most Requested URIs",
-                     compact: true,
-                     headers: ["URI", "Hits", "Visitors", "Size"],
-                     name: "pages"
-
-puts "Total of #{table.size} entries."
-
-#
-# 404s (Pages)
-#
-
-table = log_filtered.select { |x| x[:status] == "404" and x[:type] == ".html" }.map { |x| x[:uri] }.uniq_with_count
-
-OrgTableEmitter.emit table.prepare_for_output(reverse: true, sort: 0, limit: limit),
-                     title: "* HTML 404s",
-                     compact: true,
-                     headers: ["Page", "Misses"],
-                     name: "page_miss"
-
-puts "Total of #{table.size} entries."
-
-#
-# 404s URIs
-#
-
-table = log_filtered.select { |x| x[:status] == "404" and x[:type] != ".html" }.map { |x| x[:uri] }.uniq_with_count
-
-OrgTableEmitter.emit table.prepare_for_output(reverse: true, sort: 0, limit: limit),
-                     title: "* HTML 404s",
-                     compact: true,
-                     headers: ["Page", "Misses"],
-                     name: "page_miss"
-
-puts "Total of #{table.size} entries."
+require 'apache_log_report.rb'
 
 #
-# Attacks
+# Parse Command Line Arguments
 #
-def reasonable_response_type ext
-  [ ".html", ".css", ".js", ".jpg", ".svg", ".png", ".woff", ".xml", ".ttf", ".ico", ".pdf", ".htm", ".txt", ".org" ].include? ext.downcase
-end
-
-table = log_filtered.select { |x| x[:status] != "200" and not reasonable_response_type(x[:type]) }.map { |x| x[:uri] }.uniq_with_count
-
-OrgTableEmitter.emit table.prepare_for_output(reverse: true, sort: 0, limit: limit),
-                     title: "* Possible Attacks",
-                     compact: true,
-                     headers: ["Request", "Count"],
-                     name: "attacks"
-
-puts "Total of #{table.size} entries."
-
-#
-# IPs
-#
-
-table = group_and_count log_success, lambda { |x| x[:ip] }
-
-OrgTableEmitter.emit table.prepare_for_output(sort: :key, reverse: true, limit: limit),
-                     title: "* IPs",
-                     compact: true,
-                     headers: ["IP", "Hits", "Visitors", "Size"],
-                     name: "ips"
-
-puts "Total of #{table.size} entries."
-
-#
-# Statuses, Browsers and Platforms
-#
-
-[:status, :browser, :platform].each do |what|
-
-  result = log_filtered.map { |x| x[what] }.uniq_with_count
-
-  OrgTableEmitter.emit result.prepare_for_output(sort: :key),
-                       title: "* #{what.to_s.capitalize}",
-                       compact: true,
-                       headers: [what.to_s.capitalize, "Hits"],
-                       name: what.to_s
-
-  puts <<EOS
-#+BEGIN_SRC gnuplot :var data = #{what.to_s} :results output :exports both :file #{prefix}#{what.to_s}#{suffix}.svg
-reset 
-set grid ytics linestyle 0
-set terminal svg size 1200,800 fname 'Arial' fsize 10
-
-set style fill solid 0.25
-set boxwidth 0.6
 
-plot data using 2:xtic(1) with boxes lc rgb "#0000AA" title "Hits", \\
-     data using ($0):($2+100):2 with labels textcolor rgb "#0000AA"
-#+END_SRC
-EOS
+@command  = ARGV.join(" ")
+@options  = ApacheLogReport.options_parse ARGV
+@log_file = ARGV[0]
 
+if @log_file and not File.exist? @log_file
+  puts "Error: file #{log_file} does not exist"
+  exit 1
 end
 
 #
-# Statuses by day
+# Parse Log and Track Statistics
 #
-result = group_and_generic_count log_filtered,
-                                 lambda { |x| x[:date_time].to_date },
-                                 lambda { |x| h = Hash.new;
-                                              h["4xx"] = x.select { |y| y[:status][0] == "4" }.count;
-                                              h["3xx"] = x.select { |y| y[:status][0] == "3" }.count;
-                                              h["2xx"] = x.select { |y| y[:status][0] == "2" }.count;
-                                              h }
-
-OrgTableEmitter.emit result.prepare_for_output(sort: :key),
-                     title: "* Daily Status",
-                     compact: true,
-                     headers: ["Day", "4xx", "3xx", "2xx"],
-                     name: "daily_statuses"
-
-puts <<EOS
-#+BEGIN_SRC gnuplot :var data = daily_statuses :results output :exports both :file #{prefix}daily-statuses#{suffix}.svg
-reset 
-set terminal svg size 1200,800 fname 'Arial' fsize 10
-
-set grid ytics linestyle 0
 
-set title "Daily Statuses"
-set xlabel "Date"
-set ylabel "Number of Hits"
-set xtics rotate by 60 right
-
-set style fill solid 0.25
-set boxwidth 0.6
-
-set style data histograms
-set style histogram clustered gap 1
-
-plot data using 2:xtic(1) lc rgb "#CC0000" title "4xx",     \\
-     data using 3 lc rgb "#0000CC" title "3xx", \\
-     data using 4 lc rgb "#00AA00" title "2xx", \\
-     data using ($0 - 1. / 4):($2 + 0.5):2 with labels title "" textcolor rgb("#CC0000"), \\
-     data using ($0):($3 + 0.5):3 with labels title "" textcolor rgb("#0000CC"), \\
-     data using ($0 + 1. / 4):($4 + 0.5):4 with labels title "" textcolor rgb("#00AA00")
-#+END_SRC
-
-EOS
+@started_at = Time.now
+@db = ApacheLogReport.parse @log_file
+ApacheLogReport.analyze_data @db, @options
+@ended_at = Time.now
+@duration = @ended_at - @started_at
 
 #
-# Referer
+# Emit Output
 #
-result = group_and_count log_filtered, lambda { |x| begin
-                                                      URI(x[:referer]).host
-                                                    rescue Exception
-                                                      ""
-                                                    end  }
-good_result = result.reject! { |k| k == nil } 
-
-OrgTableEmitter.emit good_result.prepare_for_output(sort: :key),
-                     title: "* Referer",
-                     compact: true,
-                     headers: ["Referer", "Hits", "Visitors", "Size"],
-                     name: "referers"
-
-puts <<EOS
-#+BEGIN_SRC gnuplot :var data = referers :results output :exports both :file #{prefix}referers#{suffix}.svg
-reset 
-set terminal svg size 1200,800 fname 'Arial' fsize 10
-
-set grid ytics linestyle 0
-set grid xtics linestyle 0
-
-set title "Referers"
-set xlabel "Date"
-set xtics rotate by 60 right
-set ylabel "Hits and Visits"
-
-set style fill solid 0.45
-set boxwidth 0.7
-
-set style data histograms
-set style histogram clustered gap 1
-
-plot data using 2:xtic(1) lc rgb "#AA00AA" title "Hits",     \\
-     data using 3 lc rgb "#0AAAA0" title "Visits", \\
-     data using ($0 - 1. / 3):($2 + 50):2 with labels title "" textcolor rgb("#AA00AA"), \\
-     data using ($0 + 1. / 3):($3 + 50):3 with labels title "" textcolor rgb("#0AAAA0")
-#+END_SRC
-EOS
-
-puts <<EOS
-* Local Variables                                                  :noexport:
-# Local Variables:
-# org-confirm-babel-evaluate: nil
-# org-display-inline-images: t
-# end:
-EOS
-
-ended_at = Time.now
-duration = ended_at - started_at
-
-puts <<EOS
-** Performance
-
-| Analysis started at | #{started_at.to_s}           |
-| Analysis ended at   | #{ended_at.to_s}             |
-| Duration (sec)      | #{"%.3d" % duration }        |
-| Duration (min)      | #{"%.3d" % (duration / 60 )} |
-| Log size            | #{log.size}                  |
-| Entries Parsed      | #{log_input.size}            |
-| Lines/sec           | #{log_input.size / duration} |
-EOS
+puts ApacheLogReport.emit @options, @command, @log_file, @started_at, @ended_at, @duration