indy 0.1.2 → 0.1.3

data/History.txt

@@ -1,4 +1,9 @@
-=== 0.1.2 / 2011-01-18
+=== 0.1.3 / 2011-01-18
+
+* Faster (than a turtle)
+* Lighter (than a tank)
+
+=== 0.1.2 / 2011-01-17
 
 * Predefined log formats for NCSA Common, NCSA Combined, and Log4r (default)
 * Source IO is explicitly closed after each #_search

data/indy.gemspec

@@ -30,7 +30,7 @@ Gem::Specification.new do |s|
   s.name        = 'indy'
   s.version     = ::Indy::VERSION
   s.authors     = ["Franklin Webber","Brandon Faloona"]
-  s.description = %{ Indy is a log archelogy tool that allows you to interact with log data like an object while you search by fields and/or time.}
+  s.description = %{ Indy is a log archelogy tool explore logs like objects and search by field and/or time.}
   s.summary     = "Log Search Tool"
   s.email       = 'franklin.webber@gmail.com'
   s.homepage    = "http://github.com/burtlo/Indy"
@@ -41,6 +41,8 @@ Gem::Specification.new do |s|
   s.add_dependency('activesupport', '>= 2.3.5')
 
   s.add_development_dependency('cucumber', '>= 0.9.2')
+  s.add_development_dependency('yard', '>= 0.6.4')
+  s.add_development_dependency('cucumber-in-the-yard', '>= 1.7.7')
   s.add_development_dependency('rspec', '>= 2.4.0')
   s.add_development_dependency('rspec-mocks', '>= 2.4.0')
   s.add_development_dependency('rspec-prof', '>= 0.0.3')

data/lib/indy/indy.rb

@@ -3,7 +3,7 @@ require 'active_support/core_ext'
 
 class Indy
 
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 
   #
   # hash with one key (:string, :file, or :cmd) set to the string that defines the log
@@ -37,15 +37,14 @@ class Indy
   #  Indy.new(:time_format => '%m-%d-%Y',:pattern => [LOG_REGEX_PATTERN,:time,:application,:message],:source => LOG_FILENAME)
   #
   def initialize(args)
-    @source = @pattern = nil
+    @source = @pattern = @time_format = @log_regexp = @log_fields = nil
     @source = Hash.new
 
     while (arg = args.shift) do
       send("#{arg.first}=",arg.last)
     end
 
-    @pattern = @pattern || DEFAULT_LOG_PATTERN
-    @time_field = ( @pattern[1..-1].include?(:time) ? :time : nil )
+    update_log_pattern(@pattern)
 
   end
 
@@ -98,11 +97,10 @@ class Indy
   #  Indy.search(LOG_FILE).with(/^(\d{2}.\d{2}.\d{2})\s*(.+)$/,:time,:message)
   #
   def with(pattern_array = :default)
-    @pattern = pattern_array == :default ? DEFAULT_LOG_PATTERN : pattern_array
-    @time_field = @pattern[1..-1].include?(:time) ? :time : nil
+    update_log_pattern( pattern_array )
     self
   end
-
+  
   #
   # Search the source and make an == comparison
   #
@@ -113,308 +111,360 @@ class Indy
   def for(search_criteria)
     results = ResultSet.new
 
+    define_struct
+
     case search_criteria
     when Enumerable
       results += _search do |result|
-        OpenStruct.new(result) if search_criteria.reject {|criteria,value| result[criteria] == value }.empty?
+        create_struct(result) if search_criteria.reject {|criteria,value| result[criteria] == value }.empty?
       end
+
     when :all
-      results += _search {|result| OpenStruct.new(result) }
+      results += _search {|result| create_struct(result) }
     end
 
     results
   end
 
 
-    #
-    # Search the source and make a regular expression comparison
-    #
-    # @param [Hash] search_criteria the field to search for as the key and the
-    #        value to compare against the other log messages
-    #
-    # @example For all applications that end with Service
-    #
-    #  Indy.search(LOG_FILE).like(:application => '(.+)Service')
-    #
-    def like(search_criteria)
-      results = ResultSet.new
-
-      results += _search do |result|
-        OpenStruct.new(result) if search_criteria.reject {|criteria,value| result[criteria] =~ /#{value}/ }.empty?
-      end
+  #
+  # Search the source and make a regular expression comparison
+  #
+  # @param [Hash] search_criteria the field to search for as the key and the
+  #        value to compare against the other log messages
+  #
+  # @example For all applications that end with Service
+  #
+  #  Indy.search(LOG_FILE).like(:application => '(.+)Service')
+  #
+  def like(search_criteria)
+    results = ResultSet.new
+    define_struct
 
-      results
+    results += _search do |result|
+      create_struct(result) if search_criteria.reject {|criteria,value| result[criteria] =~ /#{value}/ }.empty?
     end
 
-    alias_method :matching, :like
+    results
+  end
 
+  alias_method :matching, :like
 
-    #
-    # After scopes the eventual search to all entries after to this point.
-    #
-    # @param [Hash] scope_criteria the field to scope for as the key and the
-    #        value to compare against the other log messages
-    #
-    # @example For all messages after specified date
-    #
-    #   Indy.search(LOG_FILE).after(:time => time).for(:all)
-    #
-    def after(scope_criteria)
-      if scope_criteria[:time]
-        time = parse_date(scope_criteria[:time])
-        @inclusive = scope_criteria[:inclusive] || false
-
-        if scope_criteria[:span]
-          span = (scope_criteria[:span].to_i * 60).seconds
-          within(:time => [time, time + span])
-        else
-          @start_time = time
-        end
-      end
 
-      self
+  #
+  # After scopes the eventual search to all entries after to this point.
+  #
+  # @param [Hash] scope_criteria the field to scope for as the key and the
+  #        value to compare against the other log messages
+  #
+  # @example For all messages after specified date
+  #
+  #   Indy.search(LOG_FILE).after(:time => time).for(:all)
+  #
+  def after(scope_criteria)
+    if scope_criteria[:time]
+      time = parse_date(scope_criteria[:time])
+      @inclusive = scope_criteria[:inclusive] || false
+
+      if scope_criteria[:span]
+        span = (scope_criteria[:span].to_i * 60).seconds
+        within(:time => [time, time + span])
+      else
+        @start_time = time
+      end
     end
 
-    #
-    # Before scopes the eventual search to all entries prior to this point.
-    #
-    # @param [Hash] scope_criteria the field to scope for as the key and the
-    #        value to compare against the other log messages
-    #
-    # @example For all messages before specified date
-    #
-    #   Indy.search(LOG_FILE).before(:time => time).for(:all)
-    #   Indy.search(LOG_FILE).before(:time => time, :span => 10).for(:all)
-    #
-    def before(scope_criteria)
-      if scope_criteria[:time]
-        time = parse_date(scope_criteria[:time])
-        @inclusive = scope_criteria[:inclusive] || false
-
-        if scope_criteria[:span]
-          span = (scope_criteria[:span].to_i * 60).seconds
-          within(:time => [time - span, time], :inclusive => scope_criteria[:inclusive])
-        else
-          @end_time = time
-        end
-      end
+    self
+  end
 
-      self
+  #
+  # Before scopes the eventual search to all entries prior to this point.
+  #
+  # @param [Hash] scope_criteria the field to scope for as the key and the
+  #        value to compare against the other log messages
+  #
+  # @example For all messages before specified date
+  #
+  #   Indy.search(LOG_FILE).before(:time => time).for(:all)
+  #   Indy.search(LOG_FILE).before(:time => time, :span => 10).for(:all)
+  #
+  def before(scope_criteria)
+    if scope_criteria[:time]
+      time = parse_date(scope_criteria[:time])
+      @inclusive = scope_criteria[:inclusive] || false
+
+      if scope_criteria[:span]
+        span = (scope_criteria[:span].to_i * 60).seconds
+        within(:time => [time - span, time], :inclusive => scope_criteria[:inclusive])
+      else
+        @end_time = time
+      end
     end
 
-    def around(scope_criteria)
-      if scope_criteria[:time]
-        time = parse_date(scope_criteria[:time])
+    self
+  end
 
-        # does @inclusive add any real value to the #around method?
-        @inclusive = scope_criteria[:inclusive] || false
+  def around(scope_criteria)
+    if scope_criteria[:time]
+      time = parse_date(scope_criteria[:time])
 
-        half_span = ((scope_criteria[:span].to_i * 60)/2).seconds rescue 300.seconds
-        within(:time => [time - half_span, time + half_span])
-      end
+      # does @inclusive add any real value to the #around method?
+      @inclusive = scope_criteria[:inclusive] || false
 
-      self
+      half_span = ((scope_criteria[:span].to_i * 60)/2).seconds rescue 300.seconds
+      within(:time => [time - half_span, time + half_span])
     end
 
+    self
+  end
 
-    #
-    # Within scopes the eventual search to all entries between two points.
-    #
-    # @param [Hash] scope_criteria the field to scope for as the key and the
-    #        value to compare against the other log messages
-    #
-    # @example For all messages within the specified dates
-    #
-    #   Indy.search(LOG_FILE).within(:time => [start_time,stop_time]).for(:all)
-    #
-    def within(scope_criteria)
-      if scope_criteria[:time]
-        @start_time, @end_time = scope_criteria[:time]
-        @inclusive = scope_criteria[:inclusive] || false
-      end
 
-      self
+  #
+  # Within scopes the eventual search to all entries between two points.
+  #
+  # @param [Hash] scope_criteria the field to scope for as the key and the
+  #        value to compare against the other log messages
+  #
+  # @example For all messages within the specified dates
+  #
+  #   Indy.search(LOG_FILE).within(:time => [start_time,stop_time]).for(:all)
+  #
+  def within(scope_criteria)
+    if scope_criteria[:time]
+      @start_time, @end_time = scope_criteria[:time]
+      @inclusive = scope_criteria[:inclusive] || false
     end
 
+    self
+  end
 
-    private
 
-    #
-    # Sets the source for the Indy instance.
-    #
-    # @param [String,Hash] source A filename, or log content as a string. Use a Hash with :cmd key to specify a command string.
-    #
-    # @example
-    #
-    #   source("apache.log")
-    #   source(:cmd => "cat apache.log")
-    #   source("INFO 2000-09-07 MyApp - Entering APPLICATION.\nINFO 2000-09-07 MyApp - Entering APPLICATION.")
-    #
-    def source=(param)
+  private
 
-      cmd = param[:cmd] rescue nil
-      @source[:cmd] = param[:cmd] if cmd
+  #
+  # Sets the source for the Indy instance.
+  #
+  # @param [String,Hash] source A filename, or log content as a string. Use a Hash with :cmd key to specify a command string.
+  #
+  # @example
+  #
+  #   source("apache.log")
+  #   source(:cmd => "cat apache.log")
+  #   source("INFO 2000-09-07 MyApp - Entering APPLICATION.\nINFO 2000-09-07 MyApp - Entering APPLICATION.")
+  #
+  def source=(param)
 
-      unless cmd
-        File.exist?(param) ? @source[:file] = param : @source[:string] = param
-      end
+    cmd = param[:cmd] rescue nil
+    @source[:cmd] = param[:cmd] if cmd
 
+    unless cmd
+      File.exist?(param) ? @source[:file] = param : @source[:string] = param
     end
 
-    #
-    # Search the @source and yield to the block the line that was found
-    # with @pattern
-    #
-    # This method is supposed to be used internally.
-    #
-    def _search(&block)
-      time_search = use_time_criteria?
-      source_io = open_source
+  end
 
-      results = source_io.each.collect do |line|
+  #
+  # Set @pattern as well as @log_regexp, @log_fields, and @time_field
+  #
+  # @param [Array] pattern_array an Array with the regular expression as the first element
+  #        followed by list of fields (Symbols) in the log entry
+  #        to use for comparison against each log line.
+  #
+  def update_log_pattern( pattern_array )
+
+    case pattern_array
+    when :default, nil
+      @pattern = DEFAULT_LOG_PATTERN
+    else
+      @pattern = pattern_array
+    end
+
+    @log_regexp, *@log_fields = @pattern
 
-        hash = parse_line(line, @pattern)
+    @time_field = ( @log_fields.include?(:time) ? :time : nil )
 
-        if time_search
-          set_time(hash)
-          next unless inside_time_window?(hash)
-        end
-        next unless hash
+  end
+
+  #
+  # Search the @source and yield to the block the line that was found
+  # with @log_regexp and @log_fields
+  #
+  # This method is supposed to be used internally.
+  #
+  def _search(&block)
 
-        block_given? ? block.call(hash) : nil
+    time_search = use_time_criteria?
 
+    source_io = open_source
+    results = source_io.each.collect do |line|
+
+      hash = parse_line(line)
+
+      if time_search
+        set_time(hash)
+        next unless inside_time_window?(hash)
+      else
+        hash[:_time] = nil if hash
       end
 
-      source_io.close if @source[:file] || @source[:cmd]
+      next unless hash
+      block_given? ? block.call(hash) : nil
 
-      results.compact
     end
 
+    source_io.close if @source[:file] || @source[:cmd]
 
-    #
-    # Return a log io object
-    #
-    def open_source
-      begin
+    results.compact
+  end
 
-        case @source.keys.first # and only
-        when :cmd
-          source_io = exec_command(@source[:cmd])
-          raise "Failed to execute command (#{@source[:cmd]})" if source_io.nil?
 
-        when :file
-          source_io = File.open(@source[:file], 'r')
-          raise "Filed to open file: #{@source[:file]}" if source_io.nil?
+  #
+  # Return a log io object
+  #
+  def open_source
+    begin
 
-        when :string
-          source_io = StringIO.new( @source[:string] )
+      case @source.keys.first # and only
+      when :cmd
+        source_io = exec_command(@source[:cmd])
+        raise "Failed to execute command (#{@source[:cmd]})" if source_io.nil?
 
-        else
-          raise "Unsupported log source: #{@source.inspect}"
-        end
+      when :file
+        source_io = File.open(@source[:file], 'r')
+        raise "Filed to open file: #{@source[:file]}" if source_io.nil?
 
-      rescue Exception => e
-        raise "Unable to open log source. (#{e.message})"
+      when :string
+        source_io = StringIO.new( @source[:string] )
+
+      else
+        raise "Unsupported log source: #{@source.inspect}"
       end
 
-      source_io
+    rescue Exception => e
+      raise "Unable to open log source. (#{e.message})"
     end
 
-    #
-    # Return a hash of field=>value pairs for the log line
-    #
-    # @param [String] line The log line
-    # @param [Array] pattern_array The match regexp string, followed by log fields
-    #   see Class method search
-    #
-    def parse_line( line, pattern_array = @pattern)
-      regexp, *fields = pattern_array
+    source_io
+  end
 
-      if /#{regexp}/.match(line)
-        values = /#{regexp}/.match(line).captures
-        raise "Field mismatch between log pattern and log data. The data is: '#{values.join(':::')}'" unless values.length == fields.length
+  #
+  # Return a hash of field=>value pairs for the log line
+  #
+  # @param [String] line The log line
+  # @param [Array] pattern_array The match regexp string, followed by log fields
+  #   see Class method search
+  #
+  def parse_line( line )
 
-        hash = Hash[ *fields.zip( values ).flatten ]
-        hash[:line] = line.strip
+    if /#{@log_regexp}/.match(line)
+      values = /#{@log_regexp}/.match(line).captures
+      raise "Field mismatch between log pattern and log data. The data is: '#{values.join(':::')}'" unless values.length == @log_fields.length
 
-        hash
-      end
-    end
+      hash = Hash[ *@log_fields.zip( values ).flatten ]
+      hash[:line] = line.strip
 
-    #
-    #  Return true if start or end time has been set, and a :time field exists
-    #
-    def use_time_criteria?
-      if @start_time || @end_time
-        # ensure both boundaries are set
-        @start_time = @start_time || FOREVER_AGO
-        @end_time = @end_time || FOREVER
-      end
+      hash
+    end
+  end
 
-      return (@time_field && @start_time && @end_time)
+  #
+  #  Return true if start or end time has been set, and a :time field exists
+  #
+  def use_time_criteria?
+    if @start_time || @end_time
+      # ensure both boundaries are set
+      @start_time = @start_time || FOREVER_AGO
+      @end_time = @end_time || FOREVER
     end
 
+    return (@time_field && @start_time && @end_time)
+  end
 
-    #
-    # Set the :_time value in the hash
-    #
-    # @param [Hash] hash The log line hash to modify
-    #
-    def set_time(hash)
-      hash[:_time] = parse_date( hash ) if hash
-    end
 
-    #
-    # Evaluate if a log line satisfies the configured time conditions
-    #
-    # @param [Hash] line_hash The log line hash to be evaluated
-    #
-    def inside_time_window?( line_hash )
-
-      if line_hash && line_hash[:_time]
-        if @inclusive
-          true unless line_hash[:_time] > @end_time or line_hash[:_time] < @start_time
-        else
-          true unless line_hash[:_time] >= @end_time or line_hash[:_time] <= @start_time
-        end
-      end
+  #
+  # Set the :_time value in the hash
+  #
+  # @param [Hash] hash The log line hash to modify
+  #
+  def set_time(hash)
+    hash[:_time] = parse_date( hash ) if hash
+  end
 
+  #
+  # Evaluate if a log line satisfies the configured time conditions
+  #
+  # @param [Hash] line_hash The log line hash to be evaluated
+  #
+  def inside_time_window?( line_hash )
+
+    if line_hash && line_hash[:_time]
+      if @inclusive
+        true unless line_hash[:_time] > @end_time or line_hash[:_time] < @start_time
+      else
+        true unless line_hash[:_time] >= @end_time or line_hash[:_time] <= @start_time
+      end
     end
 
-    #
-    # Return a valid DateTime object for the log line or string
-    #
-    # @param [String, Hash] param The log line hash, or string to be evaluated
-    #
-    def parse_date(param)
-      return nil unless @time_field
+  end
+
+  #
+  # Return a valid DateTime object for the log line or string
+  #
+  # @param [String, Hash] param The log line hash, or string to be evaluated
+  #
+  def parse_date(param)
+    return nil unless @time_field
 
-      time_string = param[@time_field] ? param[@time_field] : param
+    time_string = param[@time_field] ? param[@time_field] : param
 
-      begin
-        # Attempt the appropriate parse method
-        @time_format ? DateTime.strptime(time_string, @time_format) : DateTime.parse(time_string)
-      rescue
-        # If appropriate, fall back to simple parse method
-        DateTime.parse(time_string) if @time_format rescue nil
-      end
+    begin
+      # Attempt the appropriate parse method
+      @time_format ? DateTime.strptime(time_string, @time_format) : DateTime.parse(time_string)
+    rescue
+      # If appropriate, fall back to simple parse method
+      DateTime.parse(time_string) if @time_format rescue nil
     end
+  end
 
-    #
-    # Try opening the string as a command string, returning an IO object
-    #
-    # @param [String] command_string string of command that will return log contents
-    #
-    def exec_command(command_string)
+  #
+  # Try opening the string as a command string, returning an IO object
+  #
+  # @param [String] command_string string of command that will return log contents
+  #
+  def exec_command(command_string)
 
-      begin
-        io = IO.popen(command_string)
-        return nil if io.eof?
-      rescue
-        nil
-      end
-      io
+    begin
+      io = IO.popen(command_string)
+      return nil if io.eof?
+    rescue
+      nil
     end
+    io
+  end
 
+  #
+  # Define Struct::Line with the fields configured with @pattern
+  #
+  def define_struct
+    fields = (@log_fields + [:_time, :line]).sort_by{|e|e.to_s}
+
+    # suppress Struct 'redefining constant' warning
+    verbose = $VERBOSE
+    $VERBOSE = nil
+
+    Struct.new( "Line", *fields )
+
+    $VERBOSE = verbose
+  end
 
+  #
+  # Return a Struct::Line object populated with the values from the line_hash
+  #
+  # @param [Hash] line_hash a hash of :field_name => value pairs for one log line
+  #
+  def create_struct( line_hash )
+    params = line_hash.keys.sort_by{|e|e.to_s}.collect {|k| line_hash[k]}
+    Struct::Line.new( *params )
   end
+
+end