request-log-analyzer 1.3.4 → 1.3.6

data/lib/request_log_analyzer/file_format.rb

@@ -42,19 +42,7 @@ module RequestLogAnalyzer::FileFormat
     raise "Invalid FileFormat class" unless klass.kind_of?(Class) && klass.ancestors.include?(RequestLogAnalyzer::FileFormat::Base)
     
     @current_file_format = klass.create(*args) # return an instance of the class
-  end  
-  
-  # Makes classes aware of a file format by registering the file_format variable
-  module Awareness
-    
-    def self.included(base)
-      base.send(:attr_reader, :file_format)
-    end
-    
-    def register_file_format(format)
-      @file_format = format
-    end
-  end  
+  end
 
   # Base class for all log file format definitions. This class provides functions for subclasses to 
   # define their LineDefinitions and to define a summary report.

data/lib/request_log_analyzer/filter/anonymize.rb

@@ -19,7 +19,8 @@ module RequestLogAnalyzer::Filter
       value * ((75 + rand(50)) / 100.0)
     end
 
-    def filter(request)    
+    def filter(request)
+      # TODO: request.attributes is bad practice
       request.attributes.each do |key, value|
         if key == :ip
           request.attributes[key] = generate_random_ip

data/lib/request_log_analyzer/filter.rb

@@ -7,28 +7,24 @@ module RequestLogAnalyzer::Filter
   end
   
   # Base filter class used to filter input requests.
-  # All filters should interit from this base.  
+  # All filters should interit from this base.
   class Base
     
-    include RequestLogAnalyzer::FileFormat::Awareness
-    
-    attr_reader :log_parser
-    attr_reader :options
+    attr_reader :file_format, :options
     
     # Initializer
     # <tt>format</tt> The file format
     # <tt>options</tt> Are passed to the filters.
     def initialize(format, options = {})
-      @options    = options
-      register_file_format(format)
+      @file_format = format
+      @options     = options
     end
     
     # Return the request if the request should be kept.
     # Return nil otherwise.
     def filter(request)
-      return nil unless request
-      return request
-    end   
+      request
+    end
   end
   
 end

data/lib/request_log_analyzer/log_processor.rb

@@ -12,11 +12,9 @@ module RequestLogAnalyzer
   #
   class LogProcessor
     
-    include RequestLogAnalyzer::FileFormat::Awareness
-    
-    attr_reader :mode, :options, :sources
+    attr_reader :mode, :options, :sources, :file_format
     attr_accessor :output_file
-   
+    
     # Builds a logprocessor instance from the arguments given on the command line
     # <tt>command</tt> The command hat was used to start the log processor. This will set the 
     #    processing mode. Currently, only :strip is supported.
@@ -43,11 +41,11 @@ module RequestLogAnalyzer
     # <tt>mode</tt> The processing mode
     # <tt>options</tt> A hash with options to take into account
     def initialize(format, mode, options = {})
-      @options = options
-      @mode    = mode
-      @sources = []
+      @options     = options
+      @mode        = mode
+      @sources     = []
+      @file_format = format
       $output_file = nil
-      self.register_file_format(format)
     end
     
     # Processes input files by opening it and sending the filestream to <code>process_io</code>,

data/lib/request_log_analyzer/output/fixed_width.rb

@@ -104,7 +104,7 @@ module RequestLogAnalyzer::Output
     end
 
     # Write a link
-    # <tt>text</tt> The text in the link
+    # <tt>text</tt> The text in the link, or the URL itself if no text is given
     # <tt>url</tt> The url to link to.
     def link(text, url = nil)
       if url.nil?
@@ -114,13 +114,13 @@ module RequestLogAnalyzer::Output
       end
     end
     
-    # Generate a header for a report    
+    # Generate a header for a report
     def header
       if io.kind_of?(File)
-        puts "Request-log-analyzer summary report"
-        line
+        puts colorize("Request-log-analyzer summary report", :white, :bold)
+        line(:green)
         puts "Version #{RequestLogAnalyzer::VERSION} - written by Willem van Bergen and Bart ten Brinke"
-        puts "Request-log-analyzer website: http://github.com/wvanbergen/request-log-analyzer"
+        puts "Website: #{link('http://github.com/wvanbergen/request-log-analyzer')}"
       end
     end
     
@@ -128,8 +128,9 @@ module RequestLogAnalyzer::Output
     def footer
       puts
       puts "Need an expert to analyze your application?"
-      puts "Mail to contact@railsdoctors.com or visit us at http://railsdoctors.com"
-      puts "Thanks for using request-log-analyzer!"
+      puts "Mail to #{link('contact@railsdoctors.com')} or visit us at #{link('http://railsdoctors.com')}."
+      line(:green)
+      puts "Thanks for using #{colorize('request-log-analyzer', :white, :bold)}!"
     end
     
     # Generate a report table and push it into the output object.

data/lib/request_log_analyzer/request.rb

@@ -9,61 +9,80 @@ module RequestLogAnalyzer
   # Request#every(field_name) returns all values corresponding to the given field name as array.
   class Request
   
+    def self.inherited(klass)
+      # klass.send(:include, Converters)
+    end
+  
     module Converters
-      
+
+      # Default converter function, which converts the parsed strings to a native Ruby type
+      # using the type indication in the line definition. It will use a custom connverter
+      # method if one is available.
       def convert_value(value, capture_definition)
-        custom_converter_method = "convert_#{capture_definition[:type]}".to_sym
-        if respond_to?(custom_converter_method) 
-          send(custom_converter_method, value, capture_definition)
-        elsif !value.nil? 
-          case capture_definition[:type]
-          when :decimal;  value.to_f
-          when :float;    value.to_f
-          when :double;   value.to_f
-          when :integer;  value.to_i
-          when :int;      value.to_i
-          when :symbol;   value.to_sym
-          else;           value.to_s
-          end
-        else 
-          nil
-        end
+        return capture_definition[:default] if value.nil?
+        custom_converter_method = :"convert_#{capture_definition[:type]}"
+        send(custom_converter_method, value, capture_definition)
       end
       
+      def convert_string(value, capture_definition);  value; end
+      def convert_decimal(value, capture_definition); value.to_f; end
+      def convert_float(value, capture_definition);   value.to_f; end
+      def convert_decimal(value, capture_definition); value.to_f; end
+      def convert_int(value, capture_definition);     value.to_i; end
+      def convert_integer(value, capture_definition); value.to_i; end
+      def convert_sym(value, capture_definition);     value.to_sym; end
+      def convert_symbol(value, capture_definition);  value.to_sym; end
+      
+      # Converts :eval field, which should evaluate to a hash.
       def convert_eval(value, capture_definition)
         eval(value).inject({}) { |h, (k, v)| h[k.to_sym] = v; h} 
       rescue SyntaxError
         nil
       end
       
-      # Slow default method to parse timestamps
+      # Slow default method to parse timestamps. 
+      # Reimplement this function in a file format specific Request class
+      # to improve the timestamp parsing speed.
       def convert_timestamp(value, capture_definition)
-        DateTime.parse(value).strftime('%Y%m%d%H%M%S').to_i unless value.nil?
+        DateTime.parse(value).strftime('%Y%m%d%H%M%S').to_i
+      end
+      
+      # Converts traffic fields to (whole) bytes based on the given unit.
+      def convert_traffic(value, capture_definition)
+        case capture_definition[:unit]
+        when nil, :b, :B, :byte      then value.to_i
+        when :GB, :G, :gigabyte      then (value.to_f * 1000_000_000).round
+        when :GiB, :gibibyte         then (value.to_f * (2 ** 30)).round
+        when :MB, :M, :megabyte      then (value.to_f * 1000_000).round
+        when :MiB, :mebibyte         then (value.to_f * (2 ** 20)).round
+        when :KB, :K, :kilobyte, :kB then (value.to_f * 1000).round
+        when :KiB, :kibibyte         then (value.to_f * (2 ** 10)).round
+        else raise "Unknown traffic unit"
+        end
       end
       
+      # Convert duration fields to float, and make sure the values are in seconds.
       def convert_duration(value, capture_definition)
-        if value.nil?
-          nil
-        elsif capture_definition[:unit] == :msec
-          value.to_f / 1000.0      
-        else
-          value.to_f
+        case capture_definition[:unit]
+        when nil, :sec, :s     then value.to_f
+        when :microsec, :musec then value.to_f / 1000000.0
+        when :msec, :millisec  then value.to_f / 1000.0
+        else raise "Unknown duration unit"
         end
       end
     end
-  
-    include RequestLogAnalyzer::FileFormat::Awareness
+
+    # Install the default converter methods
     include Converters
-  
-    attr_reader :lines
-    attr_reader :attributes
+
+    attr_reader :lines, :attributes, :file_format
         
     # Initializes a new Request object. 
     # It will apply the the provided FileFormat module to this instance.
     def initialize(file_format, attributes = {})
-      @lines = []
-      @attributes = attributes
-      register_file_format(file_format)
+      @lines       = []
+      @attributes  = attributes
+      @file_format = file_format
     end
     
     # Creates a new request that was parsed from the log with the given FileFormat. The hashes
@@ -74,8 +93,10 @@ module RequestLogAnalyzer
       return request
     end
      
-    # Adds another line to the request.
-    # The line should be provides as a hash of the fields parsed from the line.
+    # Adds another line to the request when it is parsed in the LogParser.
+    #
+    # The line should be provided as a hash with the attributes line_definition, :captures,
+    # :lineno and :source set. This function is called from LogParser.
     def add_parsed_line (parsed_line)
       value_hash = parsed_line[:line_definition].convert_captured_values(parsed_line[:captures], self)
       value_hash[:line_type] = parsed_line[:line_definition].name
@@ -84,12 +105,16 @@ module RequestLogAnalyzer
       add_line_hash(value_hash)
     end
     
+    # Adds another line to the request using a plain hash.
+    #
+    # The line should be provides as a hash of the fields parsed from the line.
     def add_line_hash(value_hash)
       @lines << value_hash
       @attributes = value_hash.merge(@attributes)
     end
     
-    
+    # Adds another line to the request. This method switches automatically between
+    # the add_line_hash and add_parsed_line based on the keys of the provided hash.
     def <<(hash)
       hash[:line_definition] ? add_parsed_line(hash) : add_line_hash(hash)
     end
@@ -97,7 +122,6 @@ module RequestLogAnalyzer
     # Checks whether the given line type was parsed from the log file for this request
     def has_line_type?(line_type)
       return true if @lines.length == 1 && @lines[0][:line_type] == line_type.to_sym
-      
       @lines.detect { |l| l[:line_type] == line_type.to_sym }
     end
     

data/lib/request_log_analyzer/source/database_loader.rb

@@ -26,8 +26,7 @@ module RequestLogAnalyzer::Source
   # The Database class gets log data from the database.
   class DatabaseLoader < Base
 
-    attr_reader :source_files
-    attr_reader :requests
+    attr_reader :source_files, :file_format, :requests
 
     # Initializes the log file parser instance.
     # It will apply the language specific FileFormat module to this instance. It will use the line
@@ -35,14 +34,11 @@ module RequestLogAnalyzer::Source
     #
     # <tt>format</tt>:: The current file format instance
     # <tt>options</tt>:: A hash of options that are used by the parser
-    def initialize(format, options = {})      
-      @line_definitions = {}
-      @options          = options
+    def initialize(format, options = {})
+      super(format, options)
       @source_files     = options[:source_files]
       @parsed_requests  = 0
       @requests         = []
-      
-      self.register_file_format(format)
     end
     
     # Reads the input, which can either be a file, sequence of files or STDIN to parse

data/lib/request_log_analyzer/source/log_parser.rb

@@ -27,9 +27,8 @@ module RequestLogAnalyzer::Source
     #
     # <tt>format</tt>:: The current file format instance
     # <tt>options</tt>:: A hash of options that are used by the parser
-    def initialize(format, options = {})      
-      @line_definitions = {}
-      @options          = options
+    def initialize(format, options = {})
+      super(format, options)
       @parsed_lines     = 0
       @parsed_requests  = 0
       @skipped_lines    = 0
@@ -40,8 +39,6 @@ module RequestLogAnalyzer::Source
       
       @options[:parse_strategy] ||= DEFAULT_PARSE_STRATEGY
       raise "Unknown parse strategy" unless PARSE_STRATEGIES.include?(@options[:parse_strategy])
-      
-      self.register_file_format(format)
     end
     
     # Reads the input, which can either be a file, sequence of files or STDIN to parse
@@ -137,7 +134,7 @@ module RequestLogAnalyzer::Source
     def parse_io(io, options = {}, &block) # :yields: request
       @current_lineno = 1
       while line = io.gets
-        @progress_handler.call(:progress, io.pos) if @progress_handler && @current_lineno % 127 == 0
+        @progress_handler.call(:progress, io.pos) if @progress_handler && (@current_lineno & 255 == 0)
         
         if request_data = file_format.parse_line(line) { |wt, message| warn(wt, message) }
           @parsed_lines += 1

data/lib/request_log_analyzer/source.rb

@@ -21,9 +21,6 @@ module RequestLogAnalyzer::Source
   # RequestLogAnalyzer::Request instances that will be fed through the pipleine.
   class Base
     
-    # Make the Spurce instance aware of the current file format
-    include RequestLogAnalyzer::FileFormat::Awareness
-
     # A hash of options
     attr_reader :options
 
@@ -42,14 +39,15 @@ module RequestLogAnalyzer::Source
     # The total number of skipped requests because of filters.
     attr_reader :skipped_requests
 
-
+    # The FileFormat instance that describes the format of this source.
+    attr_reader :file_format
 
     # Initializer, which will register the file format and save any options given as a hash.
     # <tt>format</tt>:: The file format instance
     # <tt>options</tt>:: A hash of options that can be used by a specific Source implementation
     def initialize(format, options = {})
-      @options    = options
-      register_file_format(format)
+      @options     = options
+      @file_format = format
     end
     
     # The prepare method is called before the RequestLogAnalyzer::Source::Base#each_request method is called.

data/lib/request_log_analyzer/tracker/duration.rb

@@ -51,10 +51,10 @@ module RequestLogAnalyzer::Tracker
           raise "Capture mismatch for multiple values in a request"
         end
       else
-        category = @categorizer.call(request)  # options[:category].respond_to?(:call) ? options[:category].call(request) : request[options[:category]]
-        duration = @durationizer.call(request) # options[:duration].respond_to?(:call) ? options[:duration].call(request) : request[options[:duration]]
+        category = @categorizer.call(request)
+        duration = @durationizer.call(request)
   
-        if duration.kind_of?(Float) && category.kind_of?(String)
+        if duration.kind_of?(Numeric) && !category.nil?
           @categories[category] ||= {:hits => 0, :cumulative => 0.0, :min => duration, :max => duration }
           @categories[category][:hits] += 1
           @categories[category][:cumulative] += duration

data/lib/request_log_analyzer/tracker/hourly_spread.rb

@@ -41,8 +41,7 @@ module RequestLogAnalyzer::Tracker
     # Check if the timestamp in the request and store it.
     # <tt>request</tt> The request.
     def update(request)
-      request = request.attributes
-      timestamp = request[options[:field]]
+      timestamp = request.first(options[:field])
 
       @request_time_graph[timestamp.to_s[8..9].to_i] +=1
       @first = timestamp if @first.nil? || timestamp < @first

data/lib/request_log_analyzer/tracker/traffic.rb

@@ -0,0 +1,186 @@
+module RequestLogAnalyzer::Tracker
+
+  # Analyze the average and total traffic of requests
+  #
+  # === Options
+  # * <tt>:amount</tt> The amount of lines in the report
+  # * <tt>:category</tt> Proc that handles request categorization for given fileformat (REQUEST_CATEGORIZER)
+  # * <tt>:traffic</tt> The field containing the duration in the request hash.
+  # * <tt>:if</tt> Proc that has to return !nil for a request to be passed to the tracker.
+  # * <tt>:line_type</tt> The line type that contains the duration field (determined by the category proc).
+  # * <tt>:title</tt> Title do be displayed above the report  
+  # * <tt>:unless</tt> Handle request if this proc is false for the handled request.
+  class Traffic < Base
+    
+    attr_reader :categories
+
+    # Check if duration and catagory option have been received,
+    def prepare
+      raise "No traffic field set up for category tracker #{self.inspect}" unless options[:traffic]
+      raise "No categorizer set up for duration tracker #{self.inspect}" unless options[:category]
+
+      @categorizer = options[:category].respond_to?(:call) ? options[:category] : lambda { |request| request[options[:category]] }
+      @trafficizer = options[:traffic].respond_to?(:call)  ? options[:traffic]  : lambda { |request| request[options[:traffic]]  }
+      @categories = {}
+    end
+
+    # Get the duration information fron the request and store it in the different categories.
+    # <tt>request</tt> The request.
+    def update(request)
+      category = @categorizer.call(request)
+      traffic  = @trafficizer.call(request)
+
+      if traffic.kind_of?(Numeric) && !category.nil?
+        @categories[category] ||= {:hits => 0, :cumulative => 0, :min => traffic, :max => traffic }
+        @categories[category][:hits] += 1
+        @categories[category][:cumulative] += traffic
+        @categories[category][:min] = traffic if traffic < @categories[category][:min]
+        @categories[category][:max] = traffic if traffic > @categories[category][:max]
+      end
+    end
+    
+    # Get the number of hits of a specific category.
+    # <tt>cat</tt> The category
+    def hits(cat)
+      categories[cat][:hits]
+    end
+    
+    # Get the total duration of a specific category.
+    # <tt>cat</tt> The category
+    def cumulative_traffic(cat)
+      categories[cat][:cumulative]
+    end
+
+    # Get the minimal duration of a specific category.
+    # <tt>cat</tt> The category
+    def min_traffic(cat)
+      categories[cat][:min]
+    end
+
+    # Get the maximum duration of a specific category.
+    # <tt>cat</tt> The category
+    def max_traffic(cat)
+      categories[cat][:max]
+    end
+
+    # Get the average duration of a specific category.
+    # <tt>cat</tt> The category
+    def average_traffic(cat)
+      categories[cat][:cumulative].to_f / categories[cat][:hits]  
+    end
+    
+    # Get the average duration of a all categories.
+    def overall_average_traffic
+      overall_cumulative_duration.to_f / overall_hits
+    end
+    
+    # Get the cumlative duration of a all categories.
+    def overall_cumulative_traffic
+      categories.inject(0) { |sum, (name, cat)| sum + cat[:cumulative] }  
+    end
+    
+    # Get the total hits of a all categories.
+    def overall_hits
+      categories.inject(0) { |sum, (name, cat)| sum + cat[:hits] }
+    end
+
+    # Return categories sorted by hits.
+    def sorted_by_hits
+      sorted_by(:hits)
+    end
+
+    # Return categories sorted by cumulative duration.
+    def sorted_by_cumulative
+      sorted_by(:cumulative)
+    end
+
+    # Return categories sorted by cumulative duration.
+    def sorted_by_average
+      sorted_by { |cat| cat[:cumulative].to_f / cat[:hits] }
+    end
+          
+    # Return categories sorted by a given key.
+    # <tt>by</tt> The key.
+    def sorted_by(by = nil) 
+      if block_given?
+        categories.sort { |a, b| yield(b[1]) <=> yield(a[1]) } 
+      else
+        categories.sort { |a, b| b[1][by] <=> a[1][by] } 
+      end
+    end
+    
+    # Block function to build a result table using a provided sorting function.
+    # <tt>output</tt> The output object.
+    # <tt>amount</tt> The number of rows in the report table (default 10).
+    # === Options
+    #  * </tt>:title</tt> The title of the table
+    #  * </tt>:sort</tt> The key to sort on (:hits, :cumulative, :average, :min or :max)
+    def report_table(output, amount = 10, options = {}, &block)
+      
+      output.title(options[:title])
+      
+      top_categories = @categories.sort { |a, b| yield(b[1]) <=> yield(a[1]) }.slice(0...amount)
+      output.table({:title => 'Category', :width => :rest}, 
+            {:title => 'Hits',       :align => :right, :highlight => (options[:sort] == :hits), :min_width => 4}, 
+            {:title => 'Cumulative', :align => :right, :highlight => (options[:sort] == :cumulative), :min_width => 10}, 
+            {:title => 'Average',    :align => :right, :highlight => (options[:sort] == :average), :min_width => 8},
+            {:title => 'Min',        :align => :right, :highlight => (options[:sort] == :min)}, 
+            {:title => 'Max',        :align => :right, :highlight => (options[:sort] == :max)}) do |rows|
+      
+        top_categories.each do |(cat, info)|
+          rows << [cat, info[:hits], format_traffic(info[:cumulative]), format_traffic((info[:cumulative] / info[:hits]).round),
+                    format_traffic(info[:min]), format_traffic(info[:max])]
+        end
+      end
+    end
+    
+    # Formats the traffic number using x B/kB/MB/GB etc notation
+    def format_traffic(bytes)
+      return "0 B" if bytes.zero?
+      case Math.log10(bytes).floor
+      when  1...4  then '%d B'  % bytes
+      when  4...7  then '%d kB' % (bytes / 1000)
+      when  7...10 then '%d MB' % (bytes / 1000_000)
+      when 10...13 then '%d GB' % (bytes / 1000_000_000)
+      else              '%d TB' % (bytes / 1000_000_000_000)
+      end
+    end
+
+    # Generate a request duration report to the given output object
+    # By default colulative and average duration are generated.
+    # Any options for the report should have been set during initialize.
+    # <tt>output</tt> The output object
+    def report(output)
+
+      options[:report] ||= [:cumulative, :average]
+      options[:top]    ||= 20
+  
+      options[:report].each do |report|
+        case report
+        when :average
+          report_table(output, options[:top], :title => "#{title} - top #{options[:top]} by average", :sort => :average) { |cat| cat[:cumulative] / cat[:hits] }  
+        when :cumulative
+          report_table(output, options[:top], :title => "#{title} - top #{options[:top]} by sum", :sort => :cumulative) { |cat| cat[:cumulative] }
+        when :hits
+          report_table(output, options[:top], :title => "#{title} - top #{options[:top]} by hits", :sort => :hits) { |cat| cat[:hits] }
+        else
+          raise "Unknown duration report specified: #{report}!"
+        end
+      end
+      
+      output.puts
+      output.puts "#{output.colorize(title, :white, :bold)} - observed total: " + output.colorize(format_traffic(overall_cumulative_traffic), :brown, :bold)
+    end
+    
+    # Returns the title of this tracker for reports
+    def title
+      options[:title]  || 'Request traffic'
+    end
+    
+    # Returns all the categories and the tracked duration as a hash than can be exported to YAML
+    def to_yaml_object
+      return nil if @categories.empty?
+      @categories
+    end
+  end
+end

data/lib/request_log_analyzer/tracker.rb

@@ -29,6 +29,17 @@ module RequestLogAnalyzer::Tracker
     # * <tt>:line_type</tt> Line type this tracker will accept.
     def initialize(options ={})
       @options = options
+      setup_should_update_checks!
+    end
+    
+    # Sets up the tracker's should_update? checks.
+    def setup_should_update_checks!
+      @should_update_checks = []
+      @should_update_checks.push( lambda { |request| request.has_line_type?(options[:line_type]) } ) if options[:line_type]
+      @should_update_checks.push(options[:if]) if options[:if].respond_to?(:call)
+      @should_update_checks.push( lambda { |request| request[options[:if]] }) if options[:if].kind_of?(Symbol)
+      @should_update_checks.push( lambda { |request| !options[:unless].call(request) }) if options[:unless].respond_to?(:call)
+      @should_update_checks.push( lambda { |request| !request[options[:unless]] }) if options[:unless].kind_of?(Symbol)
     end
     
     # Hook things that need to be done before running here.
@@ -55,25 +66,7 @@ module RequestLogAnalyzer::Tracker
     #
     # <tt>request</tt> The request object.
     def should_update?(request)
-      return false if options[:line_type] && !request.has_line_type?(options[:line_type])
-      
-      if options[:if]
-        if options[:if].kind_of?(Symbol)
-          return false unless request[options[:if]]
-        elsif options[:if].respond_to?(:call)
-          return false unless options[:if].call(request)
-        end
-      end
-      
-      if options[:unless]
-        if options[:unless].kind_of?(Symbol)
-          return false if request[options[:unless]]
-        elsif options[:unless].respond_to?(:call)
-          return false if options[:unless].call(request)
-        end
-      end
-      
-      return true
+      @should_update_checks.all? { |c| c.call(request) }
     end
     
     # Hook report generation here.

data/lib/request_log_analyzer.rb

@@ -10,8 +10,8 @@ Encoding.default_external = 'binary' if defined? Encoding and Encoding.respond_t
 module RequestLogAnalyzer
   
   # The current version of request-log-analyzer.
-  # This will be diplayed in output reports etc.  
-  VERSION = "1.3.4"
+  # This will be diplayed in output reports etc.
+  VERSION = "1.3.6"
 
   # Loads constants in the RequestLogAnalyzer namespace using self.load_default_class_file(base, const)
   # <tt>const</tt>:: The constant that is not yet loaded in the RequestLogAnalyzer namespace. This should be passed as a string or symbol.
@@ -25,7 +25,7 @@ module RequestLogAnalyzer
   # <tt>const</tt>:: The constant to load from the base constant as a string or symbol. This should be 'Bar' or :Bar when the constant Foo::Bar is being loaded.
   def self.load_default_class_file(base, const)
     require "#{to_underscore("#{base.name}::#{const}")}"
-    base.const_get(const)
+    base.const_get(const) if base.const_defined?(const)
   end
 
   # Convert a string/symbol in camelcase (RequestLogAnalyzer::Controller) to underscores (request_log_analyzer/controller)