Performance optimizations

CHANGELOG.md

@@ -3,6 +3,9 @@
 ## Fixed
 * Make rubocop pass
 
+## Other
+* Performance optimizations (<https://github.com/splattael>) #9
+
 ## Added
 * Add formatter for lines (<https://github.com/zimbatm/lines>) #35
 * Rubocop and rake ci task

lib/lograge/formatters/key_value.rb

@@ -1,35 +1,27 @@
 module Lograge
   module Formatters
     class KeyValue
-      LOGRAGE_FIELDS = [
-        :method, :path, :format, :controller, :action, :status, :error,
-        :duration, :view, :db, :location
-      ]
-
       def call(data)
         fields = fields_to_display(data)
 
-        event = fields.reduce([]) do |message, key|
-          next message unless data.key?(key)
-
-          message << format(key, data[key])
-          message
-        end
+        event = fields.map { |key| format(key, data[key]) }
         event.join(' ')
       end
 
       def fields_to_display(data)
-        LOGRAGE_FIELDS + (data.keys - LOGRAGE_FIELDS)
+        data.keys
       end
 
       def format(key, value)
-        # Exactly preserve the previous output
-        # Parsing this can be ambigious if the error messages contains
-        # a single quote
-        value = "'#{value}'" if key == :error
-
-        # Ensure that we always have exactly two decimals
-        value = Kernel.format('%.2f', value) if value.is_a? Float
+        if key == :error
+          # Exactly preserve the previous output
+          # Parsing this can be ambigious if the error messages contains
+          # a single quote
+          value = "'#{value}'"
+        else
+          # Ensure that we always have exactly two decimals
+          value = Kernel.format('%.2f', value) if value.is_a? Float
+        end
 
         "#{key}=#{value}"
       end

lib/lograge/log_subscriber.rb

@@ -11,10 +11,10 @@ def process_action(event)
       payload = event.payload
 
       data      = extract_request(payload)
-      data.merge! extract_status(payload)
-      data.merge! runtimes(event)
-      data.merge! location(event)
-      data.merge! custom_options(event)
+      extract_status(data, payload)
+      runtimes(data, event)
+      location(data)
+      custom_options(data, event)
 
       data = before_format(data, payload)
       formatted_message = Lograge.formatter.call(data)
@@ -42,56 +42,55 @@ def extract_request(payload)
     end
 
     def extract_path(payload)
-      payload[:path].split('?').first
+      path = payload[:path]
+      index = path.index('?')
+      index ? path[0, index] : path
     end
 
-    def extract_format(payload)
-      if ::ActionPack::VERSION::MAJOR == 3 && ::ActionPack::VERSION::MINOR == 0
+    if ::ActionPack::VERSION::MAJOR == 3 && ::ActionPack::VERSION::MINOR == 0
+      def extract_format(payload)
         payload[:formats].first
-      else
+      end
+    else
+      def extract_format(payload)
         payload[:format]
       end
     end
 
-    def extract_status(payload)
-      if payload[:status]
-        { status: payload[:status].to_i }
-      elsif payload[:exception]
-        exception, message = payload[:exception]
-        { status: 500, error: "#{exception}:#{message}" }
+    def extract_status(data, payload)
+      if (status = payload[:status])
+        data[:status] = status.to_i
+      elsif (error = payload[:exception])
+        exception, message = error
+        data[:status] = 500
+        data[:error]  = "#{exception}:#{message}"
       else
-        { status: 0 }
+        data[:status] = 0
       end
     end
 
-    def custom_options(event)
-      Lograge.custom_options(event) || {}
+    def custom_options(data, event)
+      options = Lograge.custom_options(event)
+      data.merge! options if options
     end
 
     def before_format(data, payload)
       Lograge.before_format(data, payload)
     end
 
-    def runtimes(event)
-      {
-        duration: event.duration,
-        view: event.payload[:view_runtime],
-        db: event.payload[:db_runtime]
-      }.reduce({}) do |runtimes, (name, runtime)|
-        runtimes[name] = runtime.to_f.round(2) if runtime
-        runtimes
-      end
+    def runtimes(data, event)
+      payload = event.payload
+      data[:duration] = event.duration.to_f.round(2)
+      data[:view]     = payload[:view_runtime].to_f.round(2) if payload.key?(:view_runtime)
+      data[:db]       = payload[:db_runtime].to_f.round(2) if payload.key?(:db_runtime)
     end
 
-    def location(_event)
+    def location(data)
       location = Thread.current[:lograge_location]
+      return unless location
 
-      if location
-        Thread.current[:lograge_location] = nil
-        { location: location }
-      else
-        {}
-      end
+      Thread.current[:lograge_location] = nil
+      data[:location] = location
     end
   end
 end