iodine 0.4.0 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a37969c5d9707236f1d87fcc548a442908d01fd
-  data.tar.gz: 450f40d62e72cf9a575188ecd62509fc1429a771
+  metadata.gz: 3ae7877010acc419eed5fe07927ba5bbe3a58c4d
+  data.tar.gz: af9499644636b46887940f5328f0204f1f654e42
 SHA512:
-  metadata.gz: 6c3fb1a3627926510480b73a3468940c1e436c15e60c295c508003beeb8997120047a8d483df76e6bfdc0e295eb199e2222c5713c11b33da0ae97ef316e39560
-  data.tar.gz: 67291bdfbcf83e45f03aae739e17ff5b511746ef8e7aa4ba99622ecb5306d1a9c9558cef8867e93fd5469f00c031ed70a64355231f5b0f7baff0f4037c480d4e
+  metadata.gz: 30225e2179f074851eeb497a03e57a1d7e142b6f85c367b28efd99a4af3f4648fef1655a0fe599de95c05826931c726d4dc2fc4fa02597efce065b51d380a755
+  data.tar.gz: 9b28f309443e33f15ea48993ba4ff8a74c83580ad2a24957c2678b4bca333f5c50e011673613f13bc7f8f8434366e043b48d648e999a0c44e9518a9e6450370d

data/CHANGELOG.md

@@ -8,6 +8,14 @@ Please notice that this change log contains changes for upcoming releases as wel
 
 ***
 
+#### Change log v.0.4.1
+
+**Fix**: postpone warmup in fear of abuse and collisions when using `fork`. i.e., during warmup, an application might perform actions that conflict with `fork` and worker initialization, such as creating a database connection pool during warmup, or maybe spawning a thread. Now `warmup` is postponed until *after* worker processes are up and running, resulting in a per-process warmup rather than a per-cluster warmup.
+
+**Fix** move the `rake-compiler` dependency to "development" instead of "runtime". Credit to Luis Lavena (@luislavena) for exposing the issue (#19).
+
+***
+
 #### Change log v.0.4.0
 
 **Braking change**: Some of the API was changed / updated, hopefully simplified.

data/README.md

@@ -1,4 +1,4 @@
-# Iodine - HTTP / Websocket Server & EventMachine alternative: C kqueue/epoll extension
+# iodine - HTTP / Websocket Server with Pub/Sub support, optimized for Ruby MRI on Linux / BSD
 [![Logo](https://github.com/boazsegev/iodine/raw/master/logo.png)](https://github.com/boazsegev/iodine)
 
 [![Build Status](https://travis-ci.org/boazsegev/iodine.svg?branch=master)](https://travis-ci.org/boazsegev/iodine)
@@ -6,21 +6,24 @@
 [![Inline docs](http://inch-ci.org/github/boazsegev/iodine.svg?branch=master)](http://www.rubydoc.info/github/boazsegev/iodine/master/frames)
 [![GitHub](https://img.shields.io/badge/GitHub-Open%20Source-blue.svg)](https://github.com/boazsegev/iodine)
 
-Iodine is a fast concurrent web server for real-time Ruby applications, with native support for Websockets, Pub/Sub, static file service, HTTP/1.1 and Redis Pub/Sub scaling (2 connections per Iodine process).
+Iodine is a fast concurrent web server for real-time Ruby applications, with native support for:
 
-Iodine also supports custom protocol authoring, making Object Oriented **Network Services** easy to write.
+* Websockets;
+* Pub/Sub (with optional Redis Pub/Sub scaling);
+* Static file service (with automatic `gzip` support for pre-compressed versions);
+* HTTP/1.1 keep-alive and pipelining;
+* Asynchronous event scheduling and timers;
+* Client connectivity (attach client sockets to make them evented);
+* Custom protocol authoring;
+* and more!
 
 Iodine is an **evented** framework with a simple API that builds off the low level [C code library facil.io](https://github.com/boazsegev/facil.io) with support for **epoll** and **kqueue** - this means that:
 
-* Iodine can handle **thousands of concurrent connections** (tested with more then 20K connections).
-
-    That's right, Iodine isn't subject to the 1024 connection limit imposed by native Ruby and `select`/`poll` based applications.
-
-    This makes Iodine ideal for writing HTTP/2 and Websocket servers (which is what started this whole thing).
+* Iodine can handle **thousands of concurrent connections** (tested with more then 20K connections)!
 
 * Iodine supports only **Linux/Unix** based systems (i.e. OS X, Ubuntu, FreeBSD etc'), which are ideal for evented IO (while Windows and Solaris are better at IO *completion* events, which are totally different).
 
-Iodine is a C extension for Ruby, developed for Ruby MRI 2.2.2 and up... it should support the whole Ruby 2.0 MRI family, but Rack requires Ruby 2.2.2, and so Iodine matches this requirement.
+Iodine is a C extension for Ruby, developed and optimized for Ruby MRI 2.2.2 and up... it should support the whole Ruby 2.0 MRI family, but Rack requires Ruby 2.2.2, and so iodine matches this requirement.
 
 ## Iodine::Rack == a fast and powerful HTTP + Websockets server with native Pub/Sub
 
@@ -28,11 +31,11 @@ Iodine includes a light and fast HTTP and Websocket server written in C that was
 
 With `Iodine.listen2http` it's possible to run multiple HTTP applications in addition to (or instead of) the default `Iodine::Rack` HTTP service.
 
-Iodine also supports native process cluster Pub/Sub and a native RedisEngins to easily scale Iodine's Pub/Sub horizontally.
+Iodine also supports native process cluster Pub/Sub and a native RedisEngins to easily scale iodine's Pub/Sub horizontally.
 
 ### Running the web server
 
-Using the Iodine server is easy, simply add Iodine as a gem to your Rack application:
+Using the iodine server is easy, simply add iodine as a gem to your Rack application:
 
 ```ruby
 gem 'iodine', '~>0.4'
@@ -40,7 +43,7 @@ gem 'iodine', '~>0.4'
 
 Iodine will calculate, when possible, a good enough default concurrency model for lightweight applications... this might not fit your application if you use heavier database access or other blocking calls.
 
-To get the most out of Iodine, consider the amount of CPU cores available and the concurrency level the application requires.
+To get the most out of iodine, consider the amount of CPU cores available and the concurrency level the application requires.
 
 The common model of 16 threads and 4 processes can be easily adopted:
 
@@ -52,7 +55,7 @@ bundler exec iodine -p $PORT -t 16 -w 4
 
 Iodine supports an internal static file service that bypasses the Ruby layer  and serves static files directly from "C-land".
 
-This means that Iodine won't lock Ruby's GVL when sending static files. The files will be sent directly, allowing for true native concurrency.
+This means that iodine won't lock Ruby's GVL when sending static files. The files will be sent directly, allowing for true native concurrency.
 
 Since the Ruby layer is unaware of these requests, logging can be performed by turning iodine's logger on.
 
@@ -86,7 +89,7 @@ Ruby can leverage static file support (if enabled) by using the `X-Sendfile` hea
 
 This allows Ruby to send very large files using a very small memory footprint, as well as (when possible) leveraging the `sendfile` system call.
 
-i.e. (example `config.ru` for Iodine):
+i.e. (example `config.ru` for iodine):
 
 ```ruby
 app = proc do |env|
@@ -108,17 +111,31 @@ run app
 
 Go to [localhost:3000/source](http://localhost:3000/source) to download the `config.ru` file using the `X-Sendfile` extension.
 
+#### Pre-Compressed assets / files
+
+Simply `gzip` your static files and iodine will automatically recognize and send the `gz` version if the client (browser) supports the `gzip` transfer-encoding.
+
+For example, to offer a compressed version of `style.css`, run (in the terminal):
+
+      $  gzip -k -9 style.css
+
+Now, you will have two files in your folder, `style.css` and `style.css.gz`.
+
+When a browser that supports compressed encoding (which is most browsers) requests the file, iodine will recognize that a pre-compressed option exists and will prefer the `gzip` compressed version.
+
+It's as easy as that. No extra code required.
+
 ### Special HTTP `Upgrade` support
 
-Iodine's HTTP server includes special support for the Upgrade directive using Rack's `env` Hash, allowing the application to focus on services and data while Iodine takes care of the network layer.
+Iodine's HTTP server includes special support for the Upgrade directive using Rack's `env` Hash, allowing the application to focus on services and data while iodine takes care of the network layer.
 
-Upgrading an HTTP connection can be performed either using Iodine's Websocket Protocol support with `env['upgrade.websocket']` or by implementing your own protocol directly over the TCP/IP layer - be it a websocket flavor or something completely different - using `env['upgrade.tcp']`.
+Upgrading an HTTP connection can be performed either using iodine's Websocket Protocol support with `env['upgrade.websocket']` or by implementing your own protocol directly over the TCP/IP layer - be it a websocket flavor or something completely different - using `env['upgrade.tcp']`.
 
 #### Websockets
 
-When an HTTP Upgrade request is received, Iodine will set the Rack Hash's upgrade property to `true`, so that: `env[upgrade.websocket?] == true`
+When an HTTP Upgrade request is received, iodine will set the Rack Hash's upgrade property to `true`, so that: `env[upgrade.websocket?] == true`
 
-To "upgrade" the HTTP request to the Websockets protocol, simply provide Iodine with a Websocket Callback Object instance or class: `env['upgrade.websocket'] = MyWebsocketClass` or `env['upgrade.websocket'] = MyWebsocketClass.new(args)`
+To "upgrade" the HTTP request to the Websockets protocol, simply provide iodine with a Websocket Callback Object instance or class: `env['upgrade.websocket'] = MyWebsocketClass` or `env['upgrade.websocket'] = MyWebsocketClass.new(args)`
 
 Iodine will adopt the object, providing it with network functionality (methods such as `write`, `each`, `defer` and `close` will become available) and invoke it's callbacks on network events.
 
@@ -126,7 +143,7 @@ Here is a simple chatroom example we can run in the terminal (`irb`) or easily p
 
 ```ruby
 require 'iodine'
-class WebsocketEcho
+class WebsocketChat
   def on_open
     # Pub/Sub directly to the client (or use a block to process the messages)
     subscribe channel: :chat
@@ -140,7 +157,7 @@ class WebsocketEcho
 end
 Iodine::Rack.app= Proc.new do |env|
   if env['upgrade.websocket?'.freeze] && env["HTTP_UPGRADE".freeze] =~ /websocket/i.freeze
-    env['upgrade.websocket'.freeze] = WebsocketEcho # or: WebsocketEcho.new
+    env['upgrade.websocket'.freeze] = WebsocketChat # or: WebsocketChat.new
     [0,{}, []] # It's possible to set cookies for the response.
   else
     [200, {"Content-Length" => "12"}, ["Welcome Home"] ]
@@ -157,6 +174,48 @@ Iodine::Rack.public = "www/public"
 Iodine.start
 ```
 
+#### Native Pub/Sub with *optional* Redis scaling
+
+Iodine's core, `facil.io` offers a native Pub/Sub implementation. The implementation is totally native to iodine, it covers the whole process cluster and it can be easily scaled by using Redis (which isn't required except for horizontal scaling).
+
+Here's an example that adds horizontal scaling to the chat application in the previous example, so that Pub/Sub messages are published across many machines at once:
+
+```ruby
+require 'uri'
+# initialize the Redis engine for each iodine process.
+if ENV["REDIS_URL"]
+  uri = URI(ENV["REDIS_URL"])
+  Iodine.default_pubsub = Iodine::PubSub::RedisEngine.new(uri.host, uri.port, 0, uri.password)
+else
+  puts "* No Redis, it's okay, pub/sub will still run on the whole process cluster."
+end
+
+# ... the rest of the application remain unchanged.
+```
+
+The new Redis client can also be used for asynchronous Redis command execution. i.e.:
+
+```ruby
+if(Iodine.default_pubsub.is_a? Iodine::PubSub::RedisEngine)
+  # Ask Redis about all it's client connections and print out the reply.
+  Iodine.default_pubsub.send("CLIENT LIST") { |reply| puts reply }
+end
+```
+
+**Details and Limitations:**
+
+* Iodine does not use a Hash table for the Pub/Sub channels, it uses a [4 bit trie](https://en.wikipedia.org/wiki/Trie).
+
+    The cost is higher memory consumption per channel and a limitation of 1024 bytes per channel name (shorter names are better).
+
+    The bonus is high lookup times, zero chance of channel conflicts and an optimized preference for shared prefix channels (i.e. "user:1", "user:2"...).
+
+    Another added bonus is pattern publishing (is addition to pattern subscriptions) which isn't available when using Redis (since Redis doesn't support this feature).
+
+* Iodine's Redis client does *not* support multiple databases. This is both becasue [database scoping is ignored by Redis during pub/sub](https://redis.io/topics/pubsub#database-amp-scoping) and because [Redis Cluster doesn't support multiple databases](https://redis.io/topics/cluster-spec). This indicated that multiple database support just isn't worth the extra effort.
+
+* The iodine Redis client will use two Redis connections per process (one for subscriptions and the other for publishing and commands). Both connections will be automatically re-established if timeouts or errors occur.
+
 #### TCP/IP (raw) sockets
 
 Upgrading to a custom protocol (i.e., in order to implement your own Websocket protocol with special extensions) is performed almost the same way, using `env['upgrade.tcp']`. In the following (terminal) example, we'll use an echo server without direct socket echo:
@@ -188,7 +247,7 @@ This design has a number of benefits, some of them related to better IO handling
 
 Iodine::Rack imposes a few restrictions for performance and security reasons, such as that the headers (both sending and receiving) must be less than 8Kb in size. These restrictions shouldn't be an issue and are similar to limitations imposed by Apache.
 
-Of course, if you still want to use Rack's `hijack` API, Iodine will support you - but be aware that you will need to implement your own reactor and thread pool for any sockets you hijack, as well as a socket buffer for non-blocking `write` operations (why do that when you can write a protocol object and have the main reactor manage the socket?).
+Of course, if you still want to use Rack's `hijack` API, iodine will support you - but be aware that you will need to implement your own reactor and thread pool for any sockets you hijack, as well as a socket buffer for non-blocking `write` operations (why do that when you can write a protocol object and have the main reactor manage the socket?).
 
 ### Performance oriented design - but safety first
 
@@ -225,13 +284,13 @@ The slower your application code, the more threads you will need to keep the ser
 
 ### How does it compare to other servers?
 
-Personally, after looking around, the only comparable servers are Puma and Passenger, which Iodine significantly outperformed on my tests (I didn't test Passenger's enterprise version).
+Personally, after looking around, the only comparable servers are Puma and Passenger, which iodine significantly outperformed on my tests (I didn't test Passenger's enterprise version).
 
 Since the HTTP and Websocket parsers are written in C (with no RegExp), they're fairly fast.
 
-Also, Iodine's core and parsers are running outside of Ruby's global lock, meaning that they enjoy true concurrency before entering the Ruby layer (your application) - this offers Iodine a big advantage over other Ruby servers.
+Also, iodine's core and parsers are running outside of Ruby's global lock, meaning that they enjoy true concurrency before entering the Ruby layer (your application) - this offers iodine a big advantage over other Ruby servers.
 
-Another assumption Iodine makes is that it is behind a load balancer / proxy (which is the normal way Ruby applications are deployed) - this allows Iodine to disregard header validity checks (we're not checking for invalid characters) and focus it's resources on other security and performance concerns.
+Another assumption iodine makes is that it is behind a load balancer / proxy (which is the normal way Ruby applications are deployed) - this allows iodine to disregard header validity checks (we're not checking for invalid characters) and focus it's resources on other security and performance concerns.
 
 I recommend benchmarking the performance for yourself using `wrk` or `ab`:
 
@@ -254,7 +313,7 @@ end
 run App
 ```
 
-Then start comparing servers. Here are the settings I used to compare Iodine and Puma (4 processes, 16 threads):
+Then start comparing servers. Here are the settings I used to compare iodine and Puma (4 processes, 16 threads):
 
 ```bash
 $ RACK_ENV=production iodine -p 3000 -t 16 -w 4
@@ -264,11 +323,11 @@ $ RACK_ENV=production puma -p 3000 -t 16 -w 4
 ```
 
 
-When benchmarking with `wrk`, Iodine performed significantly better, (~62K req/sec vs. ~44K req/sec) while keeping a lower memory foot print (~60Mb vs. ~111Mb).
+When benchmarking with `wrk`, iodine performed significantly better, (~62K req/sec vs. ~44K req/sec) while keeping a lower memory foot print (~60Mb vs. ~111Mb).
 
-When benchmarking with `ab`, I got different results, where Iodine still performed significantly better, (~72K req/sec vs. ~36K req/sec and ~61Mb vs. ~81.6Mb). I suspect the difference between the two benchmarks has to do with system calls to `write`, but I have no real proof.
+When benchmarking with `ab`, I got different results, where iodine still performed significantly better, (~72K req/sec vs. ~36K req/sec and ~61Mb vs. ~81.6Mb). I suspect the difference between the two benchmarks has to do with system calls to `write`, but I have no real proof.
 
-Remember to compare the memory footprint after running some requests - it's not just speed that C is helping with, it's also memory management and object pooling (i.e., Iodine uses a buffer packet pool management).
+Remember to compare the memory footprint after running some requests - it's not just speed that C is helping with, it's also memory management and object pooling (i.e., iodine uses a buffer packet pool management).
 
 ## Can I try before I buy?
 
@@ -282,7 +341,7 @@ $ gem install iodine
 
 If building the native C extension fails, please note that some Ruby installations, such as on Ubuntu, require that you separately install the development headers (`ruby.h` and friends). I have no idea why they do that, as you will need the development headers for any native gems you want to install - so hurry up and get them.
 
-If you have the development headers but still can't compile the Iodine extension, [open an issue](https://github.com/boazsegev/iodine/issues) with any messages you're getting and I'll be happy to look into it.
+If you have the development headers but still can't compile the iodine extension, [open an issue](https://github.com/boazsegev/iodine/issues) with any messages you're getting and I'll be happy to look into it.
 
 ## Mr. Sandman, write me a server
 
@@ -330,7 +389,7 @@ But me, I prefer to make sure my development software runs the exact same code a
 
 Also, I don't really understand all the minute details of EventMachine's API, it kept crashing my system every time I reached 1K-2K active connections... I'm sure I just don't know how to use EventMachine, but that's just that.
 
-Besides, you're here - why not take Iodine out for a spin and see for yourself?
+Besides, you're here - why not take iodine out for a spin and see for yourself?
 
 ## Can I contribute?
 
@@ -364,7 +423,7 @@ Here's a few things you can use from this project and they seem to be handy to h
 
     This one is a simple binary tree with a Ruby GC callback. Remember to initialize the Registry (`Registry.init(owner)`) so it's "owned" by some Ruby-land object, this allows it to bridge the two worlds for the GC's mark and sweep.
 
-    I'm attaching it to one of Iodine's library classes, just in-case someone adopts my code and decides the registry should be owned by the global Object class.
+    I'm attaching it to one of iodine's library classes, just in-case someone adopts my code and decides the registry should be owned by the global Object class.
 
 * I was using a POSIX thread pool library ([`libasync.h`](https://github.com/boazsegev/facil.io/blob/master/lib/libasync.c)) until I realized how many issues Ruby has with non-Ruby threads... So now there's a Ruby-thread port for this library at ([`rb-libasync.h`](https://github.com/boazsegev/iodine/blob/master/ext/iodine/rb-libasync.h)).
 

data/examples/redis.ru

@@ -8,14 +8,13 @@
 #      REDIS_URL=redis://localhost:6379/0 iodine -t 1 -p 3030 redis.ru
 #
 require 'uri'
-# initialize the Redis engine for each Iodine process by using `Iodine.run`
+# initialize the Redis engine for each Iodine process.
 if ENV["REDIS_URL"]
   uri = URI(ENV["REDIS_URL"])
   Iodine.default_pubsub = Iodine::PubSub::RedisEngine.new(uri.host, uri.port, 0, uri.password)
 else
-  puts "* No Redis! pub/sub is limited to the process cluster."
+  puts "* No Redis, it's okay, pub/sub will still run on the whole process cluster."
 end
-puts "The default Pub/Sub engine is:", Iodine.default_pubsub
 
 # A simple router - Checks for Websocket Upgrade and answers HTTP.
 module MyHTTPRouter

data/iodine.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ['Boaz Segev']
   spec.email         = ['bo@plezi.io']
 
-  spec.summary       = ' Iodine - HTTP / Websocket Server & EventMachine alternative for Ruby MRI - a kqueue/epoll C extension.'
-  spec.description   = ' Iodine - HTTP / Websocket Server & EventMachine alternative for Ruby MRI - a kqueue/epoll C extension.'
+  spec.summary       = 'iodine - HTTP / Websocket Server with Pub/Sub support, optimized for Ruby MRI on Linux / BSD'
+  spec.description   = 'iodine - HTTP / Websocket Server with Pub/Sub support, optimized for Ruby MRI on Linux / BSD'
   spec.homepage      = 'https://github.com/boazsegev/iodine'
   spec.license       = 'MIT'
 
@@ -32,7 +32,6 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.2.2' # Because earlier versions had been discontinued
 
   spec.add_dependency 'rack'
-  spec.add_dependency 'rake-compiler', '>= 1'
 
   spec.requirements << 'A Unix based system: Linux / macOS / BSD.'
   spec.requirements << 'An updated C compiler.'
@@ -42,6 +41,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'bundler', '>= 1.10'
   spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'minitest', '>=5'
+  spec.add_development_dependency 'rake-compiler', '>= 1'
 
   # spec.post_install_message = "** WARNING!\n" \
   #                             "Iodine 0.2.0 is NOT an upgrade - it's a total rewrite, it's written in C specifically for Ruby MRI.\n\n" \

data/lib/iodine.rb

@@ -152,16 +152,18 @@ module Iodine
   # Use {warmup} when either {processes} or {threads} are set to more then 1.
   def self.warmup app
     # load anything marked with `autoload`, since autoload isn't thread safe nor fork friendly.
-    Module.constants.each do |n|
-      begin
-        Object.const_get(n)
-      rescue Exception => _e
+    Iodine.run do
+      Module.constants.each do |n|
+        begin
+          Object.const_get(n)
+        rescue Exception => _e
+        end
       end
-    end
-    ::Rack::Builder.new(app) do |r|
-      r.warmup do |a|
-        client = ::Rack::MockRequest.new(a)
-        client.get('/')
+      ::Rack::Builder.new(app) do |r|
+        r.warmup do |a|
+          client = ::Rack::MockRequest.new(a)
+          client.get('/')
+        end
       end
     end
   end

data/lib/iodine/monkeypatch.rb

@@ -11,27 +11,32 @@ module Iodine
       #
       #       require 'iodine'
       #       require 'rack'
+      #       # a String in need of decoding
       #       s = '%E3%83%AB%E3%83%93%E3%82%A4%E3%82%B9%E3%81%A8'
       #       Benchmark.bm do |bm|
       #         # Pre-Patch
-      #         bm.report("Rack")    {1_000_000.times { Rack::Utils.unescape s } }
-      #
+      #         bm.report("   Rack.unescape")    {1_000_000.times { Rack::Utils.unescape s } }
+      #         bm.report("    Rack.rfc2822")    {1_000_000.times { Rack::Utils.rfc2822(Time.now) } }
+      #         bm.report("    Rack.rfc2109")    {1_000_000.times { Rack::Utils.rfc2109(Time.now) } }
       #         # Perform Patch
-      #         Rack::Utils.class_eval do
-      #           Iodine::Base::MonkeyPatch::RackUtils.methods(false).each do |m|
-      #             define_singleton_method(m,
-      #                   Iodine::Base::MonkeyPatch::RackUtils.instance_method(m) )
-      #           end
-      #         end
-      #
+      #         Iodine.patch_rack
+      #         puts "            --- Monkey Patching Rack ---"
       #         # Post Patch
-      #         bm.report("Patched") {1_000_000.times { Rack::Utils.unescape s } }
+      #         bm.report("Patched.unescape")    {1_000_000.times { Rack::Utils.unescape s } }
+      #         bm.report(" Patched.rfc2822")    {1_000_000.times { Rack::Utils.rfc2822(Time.now) } }
+      #         bm.report(" Patched.rfc2109")    {1_000_000.times { Rack::Utils.rfc2109(Time.now) } }
       #       end && nil
       #
       # Results:
       #         user     system      total        real
-      #       Rack     8.620000   0.020000   8.640000 (  8.636676)
-      #       Patched  0.320000   0.000000   0.320000 (  0.322377)
+      #         Rack.unescape  8.660000   0.010000   8.670000 (  8.687807)
+      #         Rack.rfc2822  3.730000   0.000000   3.730000 (  3.727732)
+      #         Rack.rfc2109  3.020000   0.010000   3.030000 (  3.031940)
+      #                      --- Monkey Patching Rack ---
+      #         Patched.unescape  0.340000   0.000000   0.340000 (  0.341506)
+      #         Patched.rfc2822  0.740000   0.000000   0.740000 (  0.737796)
+      #         Patched.rfc2109  0.690000   0.010000   0.700000 (  0.700155)
+      #
       module RackUtils
       end
     end

data/lib/iodine/version.rb

@@ -1,3 +1,3 @@
 module Iodine
-  VERSION = '0.4.0'.freeze
+  VERSION = '0.4.1'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iodine
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors:
 - Boaz Segev
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-06-21 00:00:00.000000000 Z
+date: 2017-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -24,20 +24,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake-compiler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -80,8 +66,22 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '5'
-description: " Iodine - HTTP / Websocket Server & EventMachine alternative for Ruby
-  MRI - a kqueue/epoll C extension."
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+description: iodine - HTTP / Websocket Server with Pub/Sub support, optimized for
+  Ruby MRI on Linux / BSD
 email:
 - bo@plezi.io
 executables:
@@ -240,6 +240,6 @@ rubyforge_project:
 rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
-summary: Iodine - HTTP / Websocket Server & EventMachine alternative for Ruby MRI
-  - a kqueue/epoll C extension.
+summary: iodine - HTTP / Websocket Server with Pub/Sub support, optimized for Ruby
+  MRI on Linux / BSD
 test_files: []