rack-perf 1.1.4 → 1.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 982ef21c5a45a9448c80643d36b3655266155c48
-  data.tar.gz: f4dd94d92685d76735e3ee29e7617e353d16e221
+  metadata.gz: ba1100cc8d2413f4109571da408bb679394c0589
+  data.tar.gz: f2490f2d5558f27cb0812cd5693253b6311f9436
 SHA512:
-  metadata.gz: 5cd01ac1b4dafa423bffb853f1aa9811b32b18f0705512cd4df5eac58eaaa4ae6c4df514f3c7dda9c70b3be803b6862c7218b0bb0668adb97c10dbe41d21e33e
-  data.tar.gz: 0e83d9666467aa436673cfd298ec843e2a56e736abe2fc9226f52f7dbf82184911a48ee3d32a274ca5bc2162b6a1a73812a5cbcf79e9e926355f3e8be4c9a4c5
+  metadata.gz: 473136b6aee9a9e22af50ca0a03c96fbe1fd7ac359e7bfe81a3740e22cc583991868793ad2b5a7deef6a39df8ede0ddfd6c12b3bb46f5a8836b9f37b7a6ed9e6
+  data.tar.gz: ba208d0283d5d15aebf9947064012b69b225c6a66e0e669b5f391e1676a27ded4d292d7e2f2057c14a5ed874ccdd4114b9a5fac9546bccf8e9c9bc7a14488500

data/.ruby-version

@@ -0,0 +1 @@
+2.2.4

data/lib/rack/perf.rb

@@ -1,125 +1,171 @@
 module Rack
   class Perf
     require_relative "perf/version"
-    require 'unirest'
+    require "unirest"
 
-    attr_reader :starttime
-    private :starttime
+    HIDDEN_READABLE_FIELDS = [
+      :starttime, :endtime, :api_key,
+      :debug, :stack, :env
+    ]
 
-    attr_reader :endtime
-    private :endtime
-
-    attr_reader :api_key
-    private :api_key
-
-    attr_reader :debug
-    private :debug
+    attr_reader *HIDDEN_READABLE_FIELDS
+    private     *HIDDEN_READABLE_FIELDS
 
     def initialize(stack, api_key, debug = false)
-      @stack = stack
+      @stack   = stack
       @api_key = api_key
-      @debug = debug
+      @debug   = debug
     end
 
     def call(env)
       @env = env
 
       # log the current time now before the request starts
-      @starttime = Time.now
+      performance_tracker = PerformanceTracker.new
+      performance_tracker.start
 
       # run the current request
       request = Rack::Request.new(env)
       status, headers, body = stack.call(env)
 
       # log the end time of the request
-      @endtime = Time.now
+      performance_tracker.end
 
-      # get all extra information that we need for logging
-      # that request to Perf
-      ip_addr = request.ip
-      ip_addr = env["HTTP_X_FORWARDED_FOR"] if env["HTTP_X_FORWARDED_FOR"]
-      normalized_uri = get_normalized_path(request)
+      # normalize url
+      normalized_path = NormalizePath.new(request)
 
       # send it up as long as we don't get nil, this helps
       # in cases when we intercept asset urls that don't
       # really matter
-      if normalized_uri
-        send_data(request.ip, request.request_method, request.url, normalized_uri, status, runtime)
+      if normalized_path.path?
+        send_data                = SendDataToPerf.new
+        send_data.api_key        = @api_key
+        send_data.ip_addr        = DetermineIPAddress.new(request).ip_address
+        send_data.request_method = request.request_method
+        send_data.request_url    = request.url
+        send_data.normalized_uri = normalized_path.path
+        send_data.status_code    = status
+        send_data.time_in_millis = performance_tracker.time
+        send_data.perform!
       end
 
       # send back intended data
       [status, headers, body]
     end
 
-    # this method sends up the single timing request up to Perf
-    # TODO: queue this up in a batch
-    private def send_data(ip_addr, request_method, request_url, normalized_uri, status_code, time_in_millis)
-      head = {
-        "Content-Type" => "application/json",
-        "X-Perf-Public-API-Key" => api_key
-      }
-
-      params = {
-        'ip_addr' => ip_addr,
-        'request_method' => request_method,
-        'request_url' => request_url,
-        'normalized_uri' => normalized_uri,
-        'status_code' => status_code,
-        'time_in_millis' => time_in_millis
-      }
-
-      Unirest.post "https://data.perf.sh/ingest", headers:head, parameters:[params].to_json { |response|
-        # TODO: handle the incoming response
-      }
-    end
+    private
+
+    class NormalizePath < Struct.new(:request)
+      def path?
+        path != nil
+      end
+
+      def path
+        normalize_path
+      rescue ActionController::RoutingError
+        nil
+      end
+
+      private
 
-    # this gets us the matched normalized path so that we can aggregate
-    # on it accordingly
-    private def get_normalized_path(request)
-      path = request.path
+      def route
+        Rails.application.routes.recognize_path(request.path, method: request.request_method)
+      end
 
-      begin
-        route = Rails.application.routes.recognize_path path, method: request.request_method
+      def params
         params = {}
-        route.each{ |param, value|
-          if not ["controller", "action"].include?(param.to_s)
-            params[param.to_s] = value
-          end
-        }
 
-        normalized_path = []
-        path.split(/\//).each { |path_part|
-          params.each { |param, path_value|
-            if path_part == path_value
-              path_part = ":" + param.to_s
-            end
+        route
+          .reject { |param, value| ["controller", "action"].include?(param.to_s) }
+          .each   { |param, value| params[param.to_s] = value }
+      end
+
+      def normalize_path
+        path_split = request.path.split(/\//)
+        format     = params["format"].to_s
+
+        normalized_path = path_split.map do |path_part|
+          params.each do |param, path_value|
+            part_equals_value = path_part == path_value
+            part_equals_value_with_format = format && path_part == ("%s.%s" % [path_value, format])
 
-            if params["format"] && path_part == path_value + "." + params["format"]
-              path_part = ":" + param.to_s
+            if part_equals_value || part_equals_value_with_format
+              path_part = ":%s" % param.to_s
             end
-          }
+          end
 
-          normalized_path.push(path_part)
-        }
+          path_part
+        end
 
-        return normalized_path.join("/")
-      rescue ActionController::RoutingError
-        return nil
+        normalized_path.join("/")
       end
     end
 
-    # the time comes in unix seconds, so we need to
-    # convert it to milliseconds and round
-    private def runtime
-      ((endtime - starttime) * 1000).round
+    class DetermineIPAddress < Struct.new(:request)
+      def ip_address
+        forwarded_ip ? forwarded_ip : default_ip
+      end
+
+      private
+
+      def default_ip
+        request.ip
+      end
+
+      def forwarded_ip
+        request.env["HTTP_X_FORWARDED_FOR"]
+      end
     end
 
-    private def stack
-      @stack
+    class PerformanceTracker
+      def start
+        @starttime = Time.now
+      end
+
+      def end
+        @endtime = Time.now
+      end
+
+      def time
+        ((endtime-starttime) * 1000).round
+      end
+
+      private
+
+      attr_accessor :starttime, :endtime
     end
 
-    private def env
-      @env
+    # this method sends up the single timing request up to Perf
+    # TODO: queue this up in a batch
+    class SendDataToPerf < Struct.new(:api_key, :ip_addr, :request_method, :request_url, :normalized_uri, :status_code, :time_in_millis)
+      DESTINATION_URL = "https://data.perf.sh/ingest"
+
+      def perform!
+        Unirest.post(DESTINATION_URL, headers: headers, parameters: params_json)
+      end
+
+      private
+
+      def headers
+        { "Content-Type"          => "application/json",
+          "X-Perf-Public-API-Key" => api_key }
+      end
+
+      def params
+        { "ip_addr"        => ip_addr,
+          "request_method" => request_method,
+          "request_url"    => request_url,
+          "normalized_uri" => normalized_uri,
+          "status_code"    => status_code,
+          "time_in_millis" => time_in_millis }
+      end
+
+      def params_json
+        [params].to_json do
+          # TODO: handle the incoming response
+        end
+      end
     end
+
   end
 end

data/lib/rack/perf/version.rb

@@ -1,5 +1,5 @@
 module Rack
   class Perf
-    VERSION = "1.1.4"
+    VERSION = "1.1.6"
   end
 end

data/rack-perf.gemspec

@@ -12,6 +12,7 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{Perf middleware}
   spec.description   = %q{Rack middleware that records endpoint timing and status codes to Perf}
   spec.homepage      = "https://github.com/perflabs/rack-perf"
+  spec.license       = "GPL-3.0"
 
   spec.files         = `git ls-files -z`.split("\x0").reject do |f|
     f.match(%r{^(test|spec|features)/})
@@ -20,7 +21,9 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "unirest", "~> 1.1"
+  spec.required_ruby_version = '>= 2.0'
+
+  spec.add_dependency "unirest-2x", "~> 1.1"
   spec.add_development_dependency "bundler", "~> 1.13"
   spec.add_development_dependency "rake", "~> 10.0"
 end

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: rack-perf
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.1.6
 platform: ruby
 authors:
 - Steven Lu
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-11-05 00:00:00.000000000 Z
+date: 2016-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: unirest
+  name: unirest-2x
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -60,6 +60,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".ruby-version"
 - Gemfile
 - LICENSE.md
 - README.md
@@ -71,7 +72,8 @@ files:
 - lib/rack/perf/version.rb
 - rack-perf.gemspec
 homepage: https://github.com/perflabs/rack-perf
-licenses: []
+licenses:
+- GPL-3.0
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -81,7 +83,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="