apachecrunch 0.4 → 0.5

data/lib/format_token.rb

@@ -0,0 +1,114 @@
+require 'format_token_definition'
+require 'derivation'
+
+class ApacheCrunch
+    # Abstract for a token in a log format
+    class FormatToken
+        # Performs whatever initial population is necessary for the token.
+        def populate!; raise NotImplementedError; end
+
+        def name; raise NotImplementedError; end
+        def regex; raise NotImplementedError; end
+        def captured?; raise NotImplementedError; end
+        def derivation_rule; raise NotImplementedError; end
+    end
+
+
+    # A predefined token like %q or %r from the Apache log.
+    class PredefinedToken < FormatToken
+        def populate!(token_definition)
+            @token_definition = token_definition
+        end
+
+        def name; @token_definition.name; end
+        def regex; @token_definition.regex; end
+        def captured?; @token_definition.captured; end
+        def derivation_rule; @token_definition.derivation_rule; end
+    end
+
+
+    # A bare string in a log format.
+    class StringToken < FormatToken
+        # Initializes the instance given the string it represents
+        def populate!(string_value)
+            @_string_value = string_value
+        end
+
+        def name; nil; end
+
+        def regex
+            # Make sure there aren't any regex special characters in the string that will confuse
+            # the parsing later.
+            Regexp.escape(@_string_value)
+        end
+
+        def captured?; false; end
+        def derivation_rule; NullDerivationRule.new; end
+    end
+
+
+    # A token based on a request header.
+    class ReqheaderToken < FormatToken
+        def populate!(header_name)
+            @_name = _header_name_to_token_name(header_name)
+        end
+
+        def name; @_name; end
+        def regex; '[^"]*'; end
+        def captured?; true; end
+        def derivation_rule; NullDerivationRule.new; end
+
+        # Lowercases header name and turns hyphens into underscores
+        def _header_name_to_token_name(header_name)
+            ("reqheader_" + header_name.downcase().gsub("-", "_")).to_sym
+        end
+    end
+
+
+    # A token based on an arbitrary regular expression.
+    class RegexToken < FormatToken
+        def populate!(regex_name, regex_text)
+            @_name = "regex_#{regex_name}".to_sym
+            @_regex = regex_text
+        end
+
+        def name; @_name; end
+        def regex; @_regex; end
+        def captured?; true; end
+        def derivation_rule; NullDerivationRule.new; end
+    end
+
+
+    # Generates FormatToken instances.
+    #
+    # This class does the work of figuring out which FormatToken subclass to make.
+    class FormatTokenFactory
+        # Takes an Apache log format abbreviation and returns a corresponding FormatToken
+        def self.from_abbrev(abbrev)
+            token_def = TokenDictionary.fetch(abbrev)
+            if token_def
+                # We found it in the dictionary, so just return a Token based on it
+                tok = PredefinedToken.new
+                tok.populate!(token_def)
+            elsif abbrev !~ /^%/
+                tok = StringToken.new
+                tok.populate!(abbrev)
+            elsif abbrev == "%%"
+                tok = StringToken.new
+                tok.populate!("%")
+            elsif abbrev =~ /^%\{([A-Za-z0-9-]+)\}i/
+                # HTTP request header
+                tok = ReqheaderToken.new
+                tok.populate!($1)
+            elsif abbrev =~ /^%\{(.*?):([^}]+)\}r/
+                # Arbitrary regex
+                tok = RegexToken.new
+                tok.populate!($1, $2)
+            else
+                raise "Unable to parse format definition starting at '#{abbrev}'"
+            end
+
+            tok
+        end
+    end
+end

data/lib/format_token_definition.rb

@@ -0,0 +1,183 @@
+require 'cast'
+require 'derivation'
+
+class ApacheCrunch
+    # Defines the properties of a known Apache log format token (like %q or %h)
+    class FormatTokenDefinition
+        class << self; attr_accessor :name, :abbrev, :regex, :caster, :derivation_rule, :captured; end
+    end
+
+
+    class RemoteHostTokenDefinition < FormatTokenDefinition
+        @name = :remote_host
+        @abbrev = "%h"
+        @regex = %q![A-Za-z0-9.-]+!
+        @caster = nil
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    class LogNameTokenDefinition < FormatTokenDefinition
+        @name = :log_name
+        @abbrev = "%l"
+        @regex = %q!\S+!
+        @caster = nil
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    class RemoteUserTokenDefinition < FormatTokenDefinition
+        @name = :remote_user
+        @abbrev = "%u"
+        @regex = %q![^:]+!
+        @caster = nil
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    class TimeTokenDefinition < FormatTokenDefinition
+        @name = :time
+        @abbrev = "%t"
+        @regex = %q!\[\d\d/[A-Za-z]{3}/\d\d\d\d:\d\d:\d\d:\d\d [-+]\d\d\d\d\]!
+        @caster = nil
+        @derivation_rule = TimeDerivationRule.new
+        @captured = true
+    end
+
+
+    class ReqFirstlineTokenDefinition < FormatTokenDefinition
+        @name = :req_firstline
+        @abbrev = "%r"
+        @regex = %q![^"]+!
+        @caster = nil
+        @derivation_rule = ReqFirstlineDerivationRule.new
+        @captured = true
+    end
+
+
+    class StatusTokenDefinition < FormatTokenDefinition
+        @name = :status
+        @abbrev = "%s"
+        @regex = %q!\d+|-!
+        @caster = nil
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    class BytesSentTokenDefinition < FormatTokenDefinition
+        @name = :bytes_sent
+        @abbrev = "%b"
+        @regex = %q!\d+!
+        @caster = IntegerCast.new
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    class BytesSentTokenDefinition < FormatTokenDefinition
+        @name = :bytes_sent
+        @abbrev = "%b"
+        @regex = %q![\d-]+!
+        @caster = CLFIntegerCast.new
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    class BytesSentWithHeadersTokenDefinition < FormatTokenDefinition
+        @name = :bytes_sent_with_headers
+        @abbrev = "%O"
+        @regex = %q!\d+!
+        @caster = IntegerCast.new
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    class ServeTimeMicroTokenDefinition < FormatTokenDefinition
+        @name = :serve_time_micro
+        @abbrev = "%D"
+        @regex = %q!\d+!
+        @caster = IntegerCast.new
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    class UrlPathTokenDefinition < FormatTokenDefinition
+        @name = :url_path
+        @abbrev = "%U"
+        @regex = %q!/[^?]*!
+        @caster = nil
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    class QueryStringTokenDefinition < FormatTokenDefinition
+        @name = :query_string
+        @abbrev = "%q"
+        @regex = %q!\??\S*!
+        @caster = nil
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    class ReqMethodTokenDefinition < FormatTokenDefinition
+        @name = :req_method
+        @abbrev = "%m"
+        @regex = %q![A-Z]+!
+        @caster = nil
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    class ProtocolTokenDefinition < FormatTokenDefinition
+        @name = :protocol
+        @abbrev = "%H"
+        @regex = %q!\S+!
+        @caster = nil
+        @derivation_rule = NullDerivationRule.new
+        @captured = true
+    end
+
+
+    # Finds log format elements given information about them.
+    class TokenDictionary
+        @@_defs = [
+                RemoteHostTokenDefinition,
+                LogNameTokenDefinition,
+                RemoteUserTokenDefinition,
+                TimeTokenDefinition,
+                ReqFirstlineTokenDefinition,
+                StatusTokenDefinition,
+                BytesSentTokenDefinition,
+                BytesSentTokenDefinition,
+                BytesSentWithHeadersTokenDefinition,
+                ServeTimeMicroTokenDefinition,
+                UrlPathTokenDefinition,
+                QueryStringTokenDefinition,
+                ReqMethodTokenDefinition,
+                ProtocolTokenDefinition
+        ]
+
+        # Returns the FormatToken subclass with the given abbreviation.
+        #
+        # If none exists, returns nil.
+        def self.fetch(abbrev)
+            @@_defs.each do |token_def|
+                if token_def.abbrev == abbrev
+                    return token_def
+                end
+            end
+
+            nil
+        end
+    end
+end

data/lib/log_parser.rb

@@ -2,54 +2,58 @@ class ApacheCrunch
     # Parses a log file given a path and a Format instance
     class LogParser
         # Initializes the parser with the path to a log file and a EntryParser.
-        def initialize(path, entry_parser, file_cls=File)
-            @path = path
-            @entry_parser = entry_parser
+        def initialize(entry_parser)
+            @_entry_parser = entry_parser
+            @_log_file = nil
 
-            @_file_cls = file_cls
-            @_file = nil
+            @_File = File
         end
 
-        # Returns the next entry in the log file as a hash, or nil if we've reached EOF.
-        #
-        # The keys of the hash are names of LogFormatElements (e.g. :remote_host, 
-        # :reqheader_referer)
-        def next_entry
-            @_file = @_file_cls.open(@path) if @_file.nil?
+        # Handles dependency injection
+        def dep_inject!(file_cls)
+            @_File = file_cls
+        end
 
-            while line_text = @_file.gets
+        # Returns the next parsed line in the log file as an Entry, or nil if we've reached EOF.
+        def next_entry
+            while line_text = @_log_file.gets
+                # This is if we've reached EOF:
                 return nil if line_text.nil?
-                logline = @entry_parser.from_text(line_text)
 
+                entry = @_entry_parser.parse(@_format, line_text)
                 # The EntryParser returns nil and writes a warning if the line text doesn't
                 # match our expected format.
-                next if logline.nil?
+                next if entry.nil?
 
-                return logline
+                return entry
             end
         end
 
         # Resets the LogParser's filehandle so we can start over.
-        def reset
-            @_file = nil
+        def reset_file!
+            @_log_file.close
+            @_log_file = @_File.open(@_log_file.path)
         end
 
-        # Makes the LogParser close its current log file and start parsing a new one instead
+        # Makes the LogParser start parsing a new log file
         #
         # `new_target` is a writable file object that the parser should start parsing, and if
-        # in_place is true, we actually replace the contents of the current target with those
+        # `in_place` is true, we actually replace the contents of the current target with those
         # of the new target.
-        def replace_target(new_target, in_place)
-            new_target.close
+        def set_file!(new_file)
+            @_log_file.close unless @_log_file.nil?
+            @_log_file = new_file
+        end
 
-            if in_place
-                old_path = @_file.path
-                @_file_cls.rename(new_target.path, old_path)
-            else
-                @path = new_target.path
-            end
+        # Replaces the LogParser current file with another. Like, for real, on the filesystem.
+        def replace_file!(new_file)
+            @_log_file.close
+            @_File.rename(new_file.path, @_log_file.path)
+            @_log_file = @_File.open(@_log_file.path)
+        end
 
-            @_file = nil
+        def set_format!(format)
+            @_format = format
         end
     end
 
@@ -64,11 +68,15 @@ class ApacheCrunch
             # First we generate a Format instance based on the format definition we were given
             log_format = FormatFactory.from_format_def(format_def)
 
-            # Now we generate a line parser
-            log_line_parser = EntryParser.new(log_format, progress_meter)
+            # Now we generate a parser for the individual entries
+            entry_parser = EntryParser.new
+            entry_parser.add_progress_meter!(progress_meter)
 
             # And now we can instantiate and return a LogParser
-            return LogParser.new(path, log_line_parser)
+            log_parser = LogParser.new(entry_parser)
+            log_parser.set_file!(open(path, "r"))
+            log_parser.set_format!(log_format)
+            log_parser
         end
     end
 end

data/lib/procedure_dsl.rb

@@ -1,308 +1,318 @@
-# Abstract for a procedure routine.
-class ProcedureRoutine
-    def initialize(log_parser)
-        @_log_parser = log_parser
-        @_current_entry = nil
-    end
+require 'element_value_fetcher'
+
+class ApacheCrunch
+    # Abstract for a procedure routine.
+    class ProcedureRoutine
+        def initialize(log_parser)
+            @_log_parser = log_parser
+            @_current_entry = nil
+        end
 
-    # Allows blocks passed to a DSL routine to access parameters from the current log entry
-    def method_missing(sym, *args)
-        @_current_entry[sym]
-    end
+        # Allows blocks passed to a DSL routine to access parameters from the current log entry
+        def method_missing(sym, *args)
+            @_current_entry.fetch(sym)
+        end
 
-    # Executes the DSL routine using the given block
-    #
-    # Abstract method
-    def execute(&blk)
-        raise "Not implemented"
-    end
+        # Executes the DSL routine using the given block
+        #
+        # Abstract method
+        def execute(&blk)
+            raise "Not implemented"
+        end
 
-    # Anything that needs to happen after the routine completes but before it returns its
-    # result can go in here.
-    def finish
-        @_log_parser.reset
+        # Anything that needs to happen after the routine completes but before it returns its
+        # result can go in here.
+        def finish
+            @_log_parser.reset_file!
+        end
     end
-end
 
 
-# DSL routine that returns the number of log entries where the block evaluates to true
-class CountWhere < ProcedureRoutine
-    def execute(&blk)
-        count = 0
-        while @_current_entry = @_log_parser.next_entry
-            if instance_eval(&blk)
-                count += 1
+    # DSL routine that returns the number of log entries where the block evaluates to true
+    class CountWhere < ProcedureRoutine
+        def execute(&blk)
+            count = 0
+            while @_current_entry = @_log_parser.next_entry
+                if instance_eval(&blk)
+                    count += 1
+                end
             end
+            count
         end
-        count
     end
-end
 
 
-# DSL routine that executes the block for every log entry
-class Each < ProcedureRoutine
-    def execute(&blk)
-        while @_current_entry = @_log_parser.next_entry
-            instance_eval(&blk)
+    # DSL routine that executes the block for every log entry
+    class Each < ProcedureRoutine
+        def execute(&blk)
+            while @_current_entry = @_log_parser.next_entry
+                instance_eval(&blk)
+            end
         end
     end
-end
 
 
-# DSL routine(s) that filter(s) for entries for which the given block evaluates to true
-#
-# This can be called as 'filter()', which means the filtering happens in a temporary file, or
-# as 'filter(path)', which means the filtering happens in the given file.  It can also be called
-# as 'filter!()', which means the filtering happens in place, clobbering what's in apachecrunch's
-# target file.
-class Filter < ProcedureRoutine
-    def execute(path=nil, in_place=false, &blk)
-        @_in_place = in_place
-        @_results_file = _make_results_file(path, in_place)
-
-        while @_current_entry = @_log_parser.next_entry
-            if instance_eval(&blk)
-                @_results_file.write(@_current_entry[:text])
+    # DSL routine(s) that filter(s) for entries for which the given block evaluates to true
+    #
+    # This can be called as 'filter()', which means the filtering happens in a temporary file, or
+    # as 'filter(path)', which means the filtering happens in the given file.  It can also be called
+    # as 'filter!()', which means the filtering happens in place, clobbering what's in apachecrunch's
+    # target file.
+    class Filter < ProcedureRoutine
+        def execute(path=nil, in_place=false, &blk)
+            @_in_place = in_place
+            @_results_file = _make_results_file(path, in_place)
+
+            while @_current_entry = @_log_parser.next_entry
+                if instance_eval(&blk)
+                    @_results_file.write(@_current_entry.fetch(:text))
+                end
             end
         end
-    end
 
-    def finish
-        @_log_parser.replace_target(@_results_file, @_in_place)
-    end
+        def finish
+            @_results_file.close
+            @_results_file = open(@_results_file.path)
+            if @_in_place
+                @_log_parser.replace_file!(@_results_file)
+            else
+                @_log_parser.set_file!(@_results_file)
+            end
+        end
 
-    # Returns a writable file object to which the results of the filter should be written.
-    def _make_results_file(path, in_place)
-        if path.nil?
-            # If no path passed (this includes the case where the filter is being performed
-            # in place), we want a temp file.
-            return Tempfile.new("apachecrunch")
-        else
-            return open(path, "w")
+        # Returns a writable file object to which the results of the filter should be written.
+        def _make_results_file(path, in_place)
+            if path.nil?
+                # If no path passed (this includes the case where the filter is being performed
+                # in place), we want a temp file.
+                return Tempfile.new("apachecrunch")
+            else
+                return open(path, "w")
+            end
         end
     end
-end
 
-# DSL routine that returns the count of entries with each found value of the given block
-#
-# You might for instance run this with the block { status }, and you'd get back something like
-# {"200" => 941, "301" => 41, "404" => 2, "500" => 0}
-class CountBy < ProcedureRoutine
-    def execute(&blk)
-        counts = {}
-        while @_current_entry = @_log_parser.next_entry
-            val = instance_eval(&blk)
-            if counts.key?(val)
-                counts[val] += 1
-            else
-                counts[val] = 1
+    # DSL routine that returns the count of entries with each found value of the given block
+    #
+    # You might for instance run this with the block { status }, and you'd get back something like
+    # {"200" => 941, "301" => 41, "404" => 2, "500" => 0}
+    class CountBy < ProcedureRoutine
+        def execute(&blk)
+            counts = {}
+            while @_current_entry = @_log_parser.next_entry
+                val = instance_eval(&blk)
+                if counts.key?(val)
+                    counts[val] += 1
+                else
+                    counts[val] = 1
+                end
             end
+            return counts
         end
-        return counts
     end
-end
 
 
-# DSL routine that finds the distribution of (numeric) values to which the given block evaluates
-#
-# For example,
-#
-#     distribution 100 do
-#         bytes_sent
-#     end
-# 
-# would return a hash with keys from 0 up by multiples of 100, the value of each being the number
-# of entries for which bytes_sent is between that key and the next key.
-class Distribution < ProcedureRoutine
-    def execute(bucket_width, &blk)
-        dist = {}
-        while @_current_entry = @_log_parser.next_entry
-            val = instance_eval(&blk)
-            k = _key_for(val, bucket_width)
-            if dist.key?(k)
-                dist[k] += 1
-            else
-                dist[k] = 1
+    # DSL routine that finds the distribution of (numeric) values to which the given block evaluates
+    #
+    # For example,
+    #
+    #     distribution 100 do
+    #         bytes_sent
+    #     end
+    # 
+    # would return a hash with keys from 0 up by multiples of 100, the value of each being the number
+    # of entries for which bytes_sent is between that key and the next key.
+    class Distribution < ProcedureRoutine
+        def execute(bucket_width, &blk)
+            dist = {}
+            while @_current_entry = @_log_parser.next_entry
+                val = instance_eval(&blk)
+                k = _key_for(val, bucket_width)
+                if dist.key?(k)
+                    dist[k] += 1
+                else
+                    dist[k] = 1
+                end
             end
-        end
 
-        # Backfill keys for which we didn't find a value
-        0.step(dist.keys.max, bucket_width).each do |k|
-            dist[k] = 0 unless dist.key?(k)
+            # Backfill keys for which we didn't find a value
+            0.step(dist.keys.max, bucket_width).each do |k|
+                dist[k] = 0 unless dist.key?(k)
+            end
+
+            dist
         end
 
-        dist
+        # Determines the key for the distribution hash given the value and step
+        def _key_for(val, bucket_width)
+            (val.to_i / bucket_width) * bucket_width
+        end
     end
 
-    # Determines the key for the distribution hash given the value and step
-    def _key_for(val, bucket_width)
-        (val.to_i / bucket_width) * bucket_width
-    end
-end
 
+    # Same as Distribution, but the buckets get expenentially wider
+    class LogDistribution < ProcedureRoutine
+        def execute(width_base, &blk)
+            dist = {}
+            while @_current_entry = @_log_parser.next_entry
+                val = instance_eval(&blk)
+                k = _key_for(val, width_base)
+                if dist.key?(k)
+                    dist[k] += 1
+                else
+                    dist[k] = 1
+                end
+            end
 
-# Same as Distribution, but the buckets get expenentially wider
-class LogDistribution < ProcedureRoutine
-    def execute(width_base, &blk)
-        dist = {}
-        while @_current_entry = @_log_parser.next_entry
-            val = instance_eval(&blk)
-            k = _key_for(val, width_base)
-            if dist.key?(k)
-                dist[k] += 1
-            else
-                dist[k] = 1
+            # Backfill keys for which we didn't find a value
+            k = dist.keys.min
+            max_key = dist.keys.max
+            while k *= width_base and k < max_key
+                dist[k] = 0 unless dist.key?(k)
             end
-        end
 
-        # Backfill keys for which we didn't find a value
-        k = dist.keys.min
-        max_key = dist.keys.max
-        while k *= width_base and k < max_key
-            dist[k] = 0 unless dist.key?(k)
+            dist
         end
 
-        dist
-    end
-
-    # Determines the key for the distribution hash given the value and logarithmic base for
-    # the bucket width
-    def _key_for(val, width_base)
-        exp = (Math.log(val) / Math.log(width_base)).to_i
-        width_base ** exp
+        # Determines the key for the distribution hash given the value and logarithmic base for
+        # the bucket width
+        def _key_for(val, width_base)
+            exp = (Math.log(val) / Math.log(width_base)).to_i
+            width_base ** exp
+        end
     end
-end
 
 
-# DSL routine that determines a confidence interval for the values to which the block evaluates
-#
-# For example,
-#
-#     confidence_interval 95 do
-#         time_to_serve
-#     end
-#
-# would return two numbers, the lower and upper bound of a 95% confidence interval for the values
-# of time_to_serve.
-class ConfidenceInterval < ProcedureRoutine
-    def execute(confidence, &blk)
-        # Build a list of all the values found
-        values = []
-        while @_current_entry = @_log_parser.next_entry
-            values << instance_eval(&blk)
-        end
-        values.sort!
+    # DSL routine that determines a confidence interval for the values to which the block evaluates
+    #
+    # For example,
+    #
+    #     confidence_interval 95 do
+    #         time_to_serve
+    #     end
+    #
+    # would return two numbers, the lower and upper bound of a 95% confidence interval for the values
+    # of time_to_serve.
+    class ConfidenceInterval < ProcedureRoutine
+        def execute(confidence, &blk)
+            # Build a list of all the values found
+            values = []
+            while @_current_entry = @_log_parser.next_entry
+                values << instance_eval(&blk)
+            end
+            values.sort!
 
-        # Determine how many values are outside the bounds of the CI
-        count_outside = (values.length * (1.0 - confidence/100.0)).to_i
+            # Determine how many values are outside the bounds of the CI
+            count_outside = (values.length * (1.0 - confidence/100.0)).to_i
 
-        # Find the bounds of the confidence interval
-        return values[count_outside / 2], values[-count_outside / 2]
+            # Find the bounds of the confidence interval
+            return values[count_outside / 2], values[-count_outside / 2]
+        end
     end
-end
-
 
-# DSL routine that finds the most common n values for the given block.
-#
-# Returns a list of lists, each of which is [value, count].  This list is sorted by count.
-class MostCommon < ProcedureRoutine
-    def execute(n, &blk)
-        counts = CountBy.new(@_log_parser).execute(&blk)
 
-        # Sort the block values descending
-        sorted_vals = counts.keys.sort do |val_a,val_b|
-            - (counts[val_a] <=> counts[val_b])
-        end
+    # DSL routine that finds the most common n values for the given block.
+    #
+    # Returns a list of lists, each of which is [value, count].  This list is sorted by count.
+    class MostCommon < ProcedureRoutine
+        def execute(n, &blk)
+            counts = CountBy.new(@_log_parser).execute(&blk)
+
+            # Sort the block values descending
+            sorted_vals = counts.keys.sort do |val_a,val_b|
+                - (counts[val_a] <=> counts[val_b])
+            end
 
-        sorted_vals[0..n].map do |val|
-            [val, counts[val]]
+            sorted_vals[0..n].map do |val|
+                [val, counts[val]]
+            end
         end
     end
-end
 
 
-# The environment in which a procedure file is evaluated.
-#
-# A procedure file is some ruby code that uses our DSL.
-class ProcedureEnvironment
-    def initialize(log_parser)
-        @_log_parser = log_parser
-    end
+    # The environment in which a procedure file is evaluated.
+    #
+    # A procedure file is some ruby code that uses our DSL.
+    class ProcedureEnvironment
+        def initialize(log_parser)
+            @_log_parser = log_parser
+        end
 
-    # Evaluates the given string as a procedure in our DSL
-    def eval_procedure(proc_string)
-        eval proc_string
-    end
+        # Evaluates the given string as a procedure in our DSL
+        def eval_procedure(proc_string)
+            eval proc_string
+        end
 
-    # DSL routine 'count_where'
-    def count_where(&blk)
-        routine = CountWhere.new(@_log_parser)
-        rv = routine.execute(&blk)
-        routine.finish
-        rv
-    end
+        # DSL routine 'count_where'
+        def count_where(&blk)
+            routine = CountWhere.new(@_log_parser)
+            rv = routine.execute(&blk)
+            routine.finish
+            rv
+        end
 
-    # DSL routine 'filter!'
-    def filter!(&blk)
-        routine = Filter.new(@_log_parser)
-        routine.execute(nil, true, &blk)
-        routine.finish
-        nil
-    end
+        # DSL routine 'filter!'
+        def filter!(&blk)
+            routine = Filter.new(@_log_parser)
+            routine.execute(nil, true, &blk)
+            routine.finish
+            nil
+        end
 
-    # DSL routine 'filter'
-    def filter(target_path=nil, &blk)
-        routine = Filter.new(@_log_parser)
-        routine.execute(target_path, &blk)
-        routine.finish
-        nil
-    end
+        # DSL routine 'filter'
+        def filter(target_path=nil, &blk)
+            routine = Filter.new(@_log_parser)
+            routine.execute(target_path, &blk)
+            routine.finish
+            nil
+        end
 
-    # DSL routine 'each'
-    def each(&blk)
-        routine = Each.new(@_log_parser)
-        routine.execute(&blk)
-        routine.finish
-        nil
-    end
+        # DSL routine 'each'
+        def each(&blk)
+            routine = Each.new(@_log_parser)
+            routine.execute(&blk)
+            routine.finish
+            nil
+        end
 
-    # DSL routine 'count_by'
-    def count_by(&blk)
-        routine = CountBy.new(@_log_parser)
-        rv = routine.execute(&blk)
-        routine.finish
-        rv
-    end
+        # DSL routine 'count_by'
+        def count_by(&blk)
+            routine = CountBy.new(@_log_parser)
+            rv = routine.execute(&blk)
+            routine.finish
+            rv
+        end
 
-    # DSL routine 'distribution'
-    def distribution(bucket_width, &blk)
-        routine = Distribution.new(@_log_parser)
-        rv = routine.execute(bucket_width, &blk)
-        routine.finish
-        rv
-    end
+        # DSL routine 'distribution'
+        def distribution(bucket_width, &blk)
+            routine = Distribution.new(@_log_parser)
+            rv = routine.execute(bucket_width, &blk)
+            routine.finish
+            rv
+        end
 
-    # DSL routine 'log_distribution'
-    def log_distribution(width_base, &blk)
-        routine = LogDistribution.new(@_log_parser)
-        rv = routine.execute(width_base, &blk)
-        routine.finish
-        rv
-    end
+        # DSL routine 'log_distribution'
+        def log_distribution(width_base, &blk)
+            routine = LogDistribution.new(@_log_parser)
+            rv = routine.execute(width_base, &blk)
+            routine.finish
+            rv
+        end
 
-    # DSL routine 'confidence_interval'
-    def confidence_interval(confidence, &blk)
-        routine = ConfidenceInterval.new(@_log_parser)
-        rv = routine.execute(confidence, &blk)
-        routine.finish
-        rv
-    end
+        # DSL routine 'confidence_interval'
+        def confidence_interval(confidence, &blk)
+            routine = ConfidenceInterval.new(@_log_parser)
+            rv = routine.execute(confidence, &blk)
+            routine.finish
+            rv
+        end
 
-    # DSL routine 'most_common'
-    def most_common(n, &blk)
-        routine = MostCommon.new(@_log_parser)
-        rv = routine.execute(n, &blk)
-        routine.finish
-        rv
+        # DSL routine 'most_common'
+        def most_common(n, &blk)
+            routine = MostCommon.new(@_log_parser)
+            rv = routine.execute(n, &blk)
+            routine.finish
+            rv
+        end
     end
 end