ethon 0.5.12 → 0.6.0

data/lib/ethon/easy/queryable.rb

@@ -10,12 +10,12 @@ module Ethon
         base.send(:attr_accessor, :escape)
       end
 
-      # Return wether there are elements in the form or not.
+      # Return wether there are elements in params or not.
       #
-      # @example Return if form is empty.
+      # @example Return if params is empty.
       #   form.empty?
       #
-      # @return [ Boolean ] True if form is empty, else false.
+      # @return [ Boolean ] True if params is empty, else false.
       def empty?
         @params.empty?
       end
@@ -102,14 +102,12 @@ module Ethon
 
       def pairs_for(v, key, pairs)
         case v
-        when Hash
-          recursively_generate_pairs(v, key, pairs)
-        when Array
+        when Hash, Array
           recursively_generate_pairs(v, key, pairs)
         when File, Tempfile
-          pairs << [Util.escape_zero_byte(key), file_info(v)]
+          pairs << [key, file_info(v)]
         else
-          pairs << [Util.escape_zero_byte(key), Util.escape_zero_byte(v)]
+          pairs << [key, v]
         end
       end
     end

data/lib/ethon/easy/response_callbacks.rb

@@ -39,7 +39,7 @@ module Ethon
       # @example Execute on_completes.
       #   request.complete
       def complete
-        if defined?(@on_complete)
+        if @on_complete
           @on_complete.each{ |callback| callback.call(self) }
         end
       end

data/lib/ethon/version.rb

@@ -1,5 +1,5 @@
 module Ethon
 
   # Ethon version.
-  VERSION = '0.5.12'
+  VERSION = '0.6.0'
 end

data/profile/benchmarks.rb

@@ -0,0 +1,137 @@
+# encoding: utf-8
+require 'ethon'
+require 'open-uri'
+require 'patron'
+require 'curb'
+require "net/http"
+require 'cgi'
+require 'benchmark'
+
+Benchmark.bm do |bm|
+
+  [100_000].each do |i|
+    puts "[ #{i} Creations]"
+
+    bm.report("String.new        ") do
+      i.times { String.new }
+    end
+
+    bm.report("Easy.new          ") do
+      i.times { Ethon::Easy.new }
+    end
+  end
+
+  GC.start
+
+  [100_000].each do |i|
+    puts "[ #{i} Escapes]"
+
+    bm.report("CGI::escape       ") do
+      i.times { CGI::escape("まつもと") }
+    end
+
+    bm.report("Easy.escape       ") do
+      e = Ethon::Easy.new
+      i.times { e.escape("まつもと") }
+    end
+  end
+
+  GC.start
+
+  [1000].each do |i|
+    puts "[ #{i} Requests]"
+
+    bm.report("net/http          ") do
+      uri = URI.parse("http://localhost:3001/")
+      i.times { Net::HTTP.get_response(uri) }
+    end
+
+    bm.report("open-uri          ") do
+      i.times { open "http://localhost:3001/" }
+    end
+
+    bm.report("patron            ") do
+      sess = Patron::Session.new
+      i.times do
+        sess.base_url = "http://localhost:3001"
+        sess.get("/")
+      end
+    end
+
+    bm.report("patron reuse      ") do
+      sess = Patron::Session.new
+      sess.base_url = "http://localhost:3001"
+      i.times do
+        sess.get("/")
+      end
+    end
+
+    bm.report("curb reuse        ") do
+      easy = Curl::Easy.new("http://localhost:3001")
+      i.times do
+        easy.perform
+      end
+    end
+
+    bm.report("Easy.perform      ") do
+      easy = Ethon::Easy.new
+      i.times do
+        easy.url = "http://localhost:3001/"
+        easy.prepare
+        easy.perform
+      end
+    end
+
+    bm.report("Easy.perform reuse") do
+      easy = Ethon::Easy.new
+      easy.url = "http://localhost:3001/"
+      easy.prepare
+      i.times { easy.perform }
+    end
+  end
+
+  GC.start
+
+  puts "[ 4 delayed Requests ]"
+
+  bm.report("net/http          ") do
+    3.times do |i|
+      uri = URI.parse("http://localhost:300#{i}/?delay=1")
+      Net::HTTP.get_response(uri)
+    end
+  end
+
+  bm.report("open-uri          ") do
+    3.times do |i|
+      open("http://localhost:300#{i}/?delay=1")
+    end
+  end
+
+  bm.report("patron            ") do
+    sess = Patron::Session.new
+    3.times do |i|
+      sess.base_url = "http://localhost:300#{i}/?delay=1"
+      sess.get("/")
+    end
+  end
+
+  bm.report("Easy.perform      ") do
+    easy = Ethon::Easy.new
+    3.times do |i|
+      easy.url = "http://localhost:300#{i}/?delay=1"
+      easy.prepare
+      easy.perform
+    end
+  end
+
+  bm.report("Multi.perform     ") do
+    multi = Ethon::Multi.new
+    3.times do |i|
+      easy = Ethon::Easy.new
+      easy.url = "http://localhost:300#{i}/?delay=1"
+      easy.prepare
+      multi.add(easy)
+    end
+    multi.perform
+  end
+end

data/profile/memory_leaks.rb

@@ -0,0 +1,113 @@
+require 'ethon'
+require 'ethon/easy'
+
+require_relative 'perf_spec_helper'
+require 'rspec/autorun'
+
+describe "low-level interactions with libcurl" do
+  describe Ethon::Multi do
+    memory_leak_test("init") do
+      Ethon::Multi.new
+    end
+
+    memory_leak_test("handle") do
+      Ethon::Multi.new.handle
+    end
+  end
+
+  describe Ethon::Easy do
+    memory_leak_test("init") do
+      Ethon::Easy.new
+    end
+
+    memory_leak_test("handle") do
+      Ethon::Easy.new.handle
+    end
+
+    memory_leak_test("headers") do
+      Ethon::Easy.new.headers = { "a" => 1, "b" => 2, "c" => 3, "d" => 4}
+    end
+
+    memory_leak_test("escape") do
+      Ethon::Easy.new.escape("the_sky&is_blue")
+    end
+  end
+
+
+  describe Ethon::Easy::Form do
+    memory_leak_test("init") do
+      Ethon::Easy::Form.new(nil, {})
+    end
+
+    memory_leak_test("first") do
+      Ethon::Easy::Form.new(nil, {}).first
+    end
+
+    memory_leak_test("last") do
+      Ethon::Easy::Form.new(nil, {}).last
+    end
+
+    memory_leak_test("materialized with some params") do
+      form = Ethon::Easy::Form.new(nil, { "a" => "1" })
+      form.materialize
+    end
+
+    memory_leak_test("materialized with a file") do
+      File.open(__FILE__, "r") do |file|
+        form = Ethon::Easy::Form.new(nil, { "a" => file })
+        form.materialize
+      end
+    end
+  end
+end
+
+describe "higher level operations" do
+  memory_leak_test("a simple request") do
+    Ethon::Easy.new(:url => "http://localhost:3001/",
+                    :forbid_reuse => true).perform
+  end
+
+  memory_leak_test("a request with headers") do
+    Ethon::Easy.new(:url => "http://localhost:3001/",
+                    :headers => { "Content-Type" => "application/json",
+                                  "Something" => "1",
+                                  "Else" => "qwerty",
+                                  "Long-String" => "aassddffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz"},
+                    :forbid_reuse => true).perform
+  end
+
+  memory_leak_test("a request with headers and params") do
+    easy = Ethon::Easy.new(:url => "http://localhost:3001/",
+                    :headers => { "Content-Type" => "application/json",
+                                  "Something" => "1",
+                                  "Else" => "qwerty",
+                                  "Long-String" => "aassddffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz"},
+                    :forbid_reuse => true)
+    easy.http_request("http://localhost:3001/",
+                      :get,
+                      :params => { "param1" => "value1",
+                                   "param2" => "value2",
+                                   "param3" => "value3",
+                                   "param4" => "value4"})
+  end
+
+  memory_leak_test("a request with headers, params, and body") do
+    easy = Ethon::Easy.new(:url => "http://localhost:3001/",
+                    :headers => { "Content-Type" => "application/json",
+                                  "Something" => "1",
+                                  "Else" => "qwerty",
+                                  "Long-String" => "aassddffgghhiijjkkllmmnnooppqqrrssttuuvvwwxxyyzz"},
+                    :forbid_reuse => true)
+    easy.http_request("http://localhost:3001/",
+                      :get,
+                      :params => { "param1" => "value1",
+                                   "param2" => "value2",
+                                   "param3" => "value3",
+                                   "param4" => "value4"},
+                      :body => {
+                        "body1" => "value1",
+                        "body2" => "value2",
+                        "body3" => "value3"
+                      })
+  end
+end

data/profile/perf_spec_helper.rb

@@ -0,0 +1,36 @@
+#### SETUP
+require 'bundler'
+Bundler.setup
+require 'rspec'
+
+require 'support/localhost_server'
+require 'support/server'
+require_relative 'support/memory_test_helpers'
+
+require 'logger'
+
+if ENV['VERBOSE']
+  Ethon.logger = Logger.new($stdout)
+  Ethon.logger.level = Logger::DEBUG
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    LocalhostServer.new(TESTSERVER.new, 3001)
+  end
+  config.include(MemoryTestHelpers)
+  config.extend(MemoryTestHelpers::TestMethods)
+end
+
+MemoryTestHelpers.setup
+MemoryTestHelpers.logger = Logger.new($stdout)
+MemoryTestHelpers.logger.level = Logger::INFO
+MemoryTestHelpers.logger.formatter = proc do |severity, datetime, progname, msg|
+  "\t\t#{msg}\n"
+end
+
+if ENV['VERBOSE']
+  MemoryTestHelpers.logger.level = Logger::DEBUG
+end
+
+MemoryTestHelpers.iterations = ENV.fetch("ITERATIONS", 10_000).to_i

data/profile/support/memory_test_helpers.rb

@@ -0,0 +1,75 @@
+require_relative 'ruby_object_leak_tracker'
+require_relative 'os_memory_leak_tracker'
+
+module MemoryTestHelpers
+  class << self
+    attr_accessor :gc_proc, :iterations, :logger
+
+    def setup
+      if RUBY_PLATFORM == "java"
+        # for leak detection
+        JRuby.objectspace = true if defined?(JRuby)
+        # for gc
+        require 'java'
+        java_import 'java.lang.System'
+        self.gc_proc = proc { System.gc }
+      else
+        self.gc_proc = proc { GC.start }
+      end
+    end
+  end
+
+  module TestMethods
+    def memory_leak_test(description, &block)
+      context(description) do
+        it "doesn't leak ruby objects" do
+          object_leak_tracker = RubyObjectLeakTracker.new
+          track_memory_usage(object_leak_tracker, &block)
+          object_leak_tracker.total_difference_between_runs.should be <= 10
+        end
+
+        it "doesn't leak OS memory (C interop check)" do
+          os_memory_leak_tracker = OSMemoryLeakTracker.new
+          track_memory_usage(os_memory_leak_tracker, &block)
+          os_memory_leak_tracker.total_difference_between_runs.should be <= 10
+        end
+      end
+    end
+  end
+
+  def track_memory_usage(tracker)
+    # Intentionally do all this setup before we do any testing
+    logger = MemoryTestHelpers.logger
+    iterations = MemoryTestHelpers.iterations
+
+    checkpoint_frequency = (iterations / 10.0).to_i
+    gc_frequency = 20
+
+    warmup_iterations = [(iterations / 3.0).to_i, 500].min
+    logger.info "Performing #{warmup_iterations} warmup iterations"
+    warmup_iterations.times do
+      yield
+      MemoryTestHelpers.gc_proc.call
+    end
+    tracker.capture_initial_memory_usage
+
+    logger.info "Performing #{iterations} iterations (checkpoint every #{checkpoint_frequency})"
+
+    iterations.times do |i|
+      yield
+
+      last_iteration = (i == iterations - 1)
+      checkpoint = last_iteration || (i % checkpoint_frequency == 0)
+
+      if checkpoint || (i % gc_frequency == 0)
+        MemoryTestHelpers.gc_proc.call
+      end
+
+      if checkpoint
+        logger.info "Iteration #{i} checkpoint"
+        tracker.capture_memory_usage
+        tracker.dump_status(logger)
+      end
+    end
+  end
+end

data/profile/support/os_memory_leak_tracker.rb

@@ -0,0 +1,47 @@
+class OSMemoryLeakTracker
+  attr_reader :current_run
+
+  def initialize
+    @previous_run = @current_run = 0
+  end
+
+  def difference_between_runs(basis=@previous_run)
+    @current_run - basis
+  end
+
+  def total_difference_between_runs
+    difference_between_runs(@initial_count_run)
+  end
+
+  def capture_initial_memory_usage
+    capture_memory_usage
+    @initial_count_run = @current_run
+  end
+
+  def capture_memory_usage
+    @previous_run = @current_run
+    @current_run = rss_bytes
+  end
+
+  def dump_status(logger)
+    delta = difference_between_runs
+    logger.add(log_level(delta), sprintf("\tTotal memory usage (kb): %d (%+d)", current_run, delta))
+  end
+
+  private
+  # amount of memory the current process "is using", in RAM
+  # (doesn't include any swap memory that it may be using, just that in actual RAM)
+  # Code loosely based on https://github.com/rdp/os/blob/master/lib/os.rb
+  # returns 0 on windows
+  def rss_bytes
+    if ENV['OS'] == 'Windows_NT'
+      0
+    else
+      `ps -o rss= -p #{Process.pid}`.to_i # in kilobytes
+    end
+  end
+
+  def log_level(delta)
+    delta > 0 ? Logger::WARN : Logger::DEBUG
+  end
+end