pitchfork 0.1.2 → 0.2.0

data/ext/pitchfork_http/pitchfork_http.rl

@@ -224,7 +224,7 @@ static int is_chunked(VALUE v)
   return rb_funcall(cHttpParser, id_is_chunked_p, 1, v) != Qfalse;
 }
 
-static void write_value(struct http_parser *hp,
+static void write_value(VALUE self, struct http_parser *hp,
                         const char *buffer, const char *p)
 {
   VALUE f = find_common_field(PTR_TO(start.field), hp->s.field_len);
@@ -244,7 +244,7 @@ static void write_value(struct http_parser *hp,
      * rack env variable.
      */
     if (CONST_MEM_EQ("VERSION", field, flen)) {
-      hp->cont = Qnil;
+      RB_OBJ_WRITE(self, &hp->cont, Qnil);
       return;
     }
     f = uncommon_field(field, flen);
@@ -296,16 +296,16 @@ static void write_value(struct http_parser *hp,
 
   e = rb_hash_aref(hp->env, f);
   if (NIL_P(e)) {
-    hp->cont = rb_hash_aset(hp->env, f, v);
+    RB_OBJ_WRITE(self, &hp->cont, rb_hash_aset(hp->env, f, v));
   } else if (f == g_http_host) {
     /*
      * ignored, absolute URLs in REQUEST_URI take precedence over
      * the Host: header (ref: rfc 2616, section 5.2.1)
      */
-     hp->cont = Qnil;
+    RB_OBJ_WRITE(self, &hp->cont, Qnil);
   } else {
     rb_str_buf_cat(e, ",", 1);
-    hp->cont = rb_str_buf_append(e, v);
+    RB_OBJ_WRITE(self, &hp->cont, rb_str_buf_append(e, v));
   }
 }
 
@@ -321,7 +321,7 @@ static void write_value(struct http_parser *hp,
   action downcase_char { downcase_char(deconst(fpc)); }
   action write_field { hp->s.field_len = LEN(start.field, fpc); }
   action start_value { MARK(mark, fpc); }
-  action write_value { write_value(hp, buffer, fpc); }
+  action write_value { write_value(self, hp, buffer, fpc); }
   action write_cont_value { write_cont_value(hp, buffer, fpc); }
   action request_method { request_method(hp, PTR_TO(mark), LEN(mark, fpc)); }
   action scheme {
@@ -439,7 +439,7 @@ static void http_parser_init(struct http_parser *hp)
 
 /** exec **/
 static void
-http_parser_execute(struct http_parser *hp, char *buffer, size_t len)
+http_parser_execute(VALUE self, struct http_parser *hp, char *buffer, size_t len)
 {
   const char *p, *pe;
   int cs = hp->cs;
@@ -485,9 +485,13 @@ static size_t hp_memsize(const void *ptr)
 }
 
 static const rb_data_type_t hp_type = {
-  "pitchfork_http",
-  { hp_mark, RUBY_TYPED_DEFAULT_FREE, hp_memsize, /* reserved */ },
-  /* parent, data, [ flags ] */
+    .wrap_struct_name = "pitchfork_http_parser",
+    .function = {
+        .dmark = hp_mark,
+        .dfree = RUBY_TYPED_DEFAULT_FREE,
+        .dsize = hp_memsize,
+    },
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static struct http_parser *data_get(VALUE self)
@@ -618,8 +622,8 @@ static VALUE HttpParser_init(VALUE self)
   struct http_parser *hp = data_get(self);
 
   http_parser_init(hp);
-  hp->buf = rb_str_new(NULL, 0);
-  hp->env = rb_hash_new();
+  RB_OBJ_WRITE(self, &hp->buf, rb_str_new(NULL, 0));
+  RB_OBJ_WRITE(self, &hp->env, rb_hash_new());
 
   return self;
 }
@@ -700,7 +704,7 @@ static VALUE HttpParser_parse(VALUE self)
   if (HP_FL_TEST(hp, TO_CLEAR))
     HttpParser_clear(self);
 
-  http_parser_execute(hp, RSTRING_PTR(data), RSTRING_LEN(data));
+  http_parser_execute(self, hp, RSTRING_PTR(data), RSTRING_LEN(data));
   if (hp->offset > MAX_HEADER_LEN)
     parser_raise(e413, "HTTP header is too large");
 
@@ -756,8 +760,8 @@ static VALUE HttpParser_headers(VALUE self, VALUE env, VALUE buf)
 {
   struct http_parser *hp = data_get(self);
 
-  hp->env = env;
-  hp->buf = buf;
+  RB_OBJ_WRITE(self, &hp->buf, buf);
+  RB_OBJ_WRITE(self, &hp->env, env);
 
   return HttpParser_parse(self);
 }
@@ -885,9 +889,9 @@ static VALUE HttpParser_filter_body(VALUE self, VALUE dst, VALUE src)
       rb_str_resize(dst, srclen); /* we can never copy more than srclen bytes */
 
       hp->s.dest_offset = 0;
-      hp->cont = dst;
-      hp->buf = src;
-      http_parser_execute(hp, srcptr, srclen);
+      RB_OBJ_WRITE(self, &hp->cont, dst);
+      RB_OBJ_WRITE(self, &hp->buf, src);
+      http_parser_execute(self, hp, srcptr, srclen);
       if (hp->cs == http_parser_error)
         parser_raise(eHttpParserError, "Invalid HTTP format, parsing fails.");
 
@@ -917,7 +921,7 @@ static VALUE HttpParser_filter_body(VALUE self, VALUE dst, VALUE src)
        * This causes copy-on-write behavior to be triggered anyways
        * when the +src+ buffer is modified (when reading off the socket).
        */
-      hp->buf = src;
+      RB_OBJ_WRITE(self, &hp->buf, src);
       memcpy(RSTRING_PTR(dst), srcptr, nr);
       hp->len.content -= nr;
       if (hp->len.content == 0) {

data/lib/pitchfork/configurator.rb

@@ -31,30 +31,29 @@ module Pitchfork
       :logger => Logger.new($stderr),
       :worker_processes => 1,
       :after_fork => lambda { |server, worker|
-          server.logger.info("worker=#{worker.nr} gen=#{worker.generation} pid=#{$$} spawned")
-        },
-      :before_fork => lambda { |server, worker|
-          server.logger.info("worker=#{worker.nr} gen=#{worker.generation} spawning...")
-        },
+        server.logger.info("worker=#{worker.nr} gen=#{worker.generation} pid=#{$$} spawned")
+      },
+      :after_promotion => lambda { |server, worker|
+        server.logger.info("gen=#{worker.generation} pid=#{$$} promoted")
+      },
       :after_worker_exit => lambda { |server, worker, status|
-          m = if worker.nil?
-            "repead unknown process (#{status.inspect})"
-          elsif worker.mold?
-            "mold pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
-          else
-            "worker=#{worker.nr rescue 'unknown'} pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
-          end
-          if status.success?
-            server.logger.info(m)
-          else
-            server.logger.error(m)
-          end
-        },
+        m = if worker.nil?
+          "repead unknown process (#{status.inspect})"
+        elsif worker.mold?
+          "mold pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
+        else
+          "worker=#{worker.nr rescue 'unknown'} pid=#{worker.pid rescue 'unknown'} gen=#{worker.generation rescue 'unknown'} reaped (#{status.inspect})"
+        end
+        if status.success?
+          server.logger.info(m)
+        else
+          server.logger.error(m)
+        end
+      },
       :after_worker_ready => lambda { |server, worker|
-          server.logger.info("worker=#{worker.nr} ready")
-        },
+        server.logger.info("worker=#{worker.nr} gen=#{worker.generation} ready")
+      },
       :early_hints => false,
-      :mold_selector => MoldSelector::LeastSharedMemory.new,
       :refork_condition => nil,
       :check_client_connection => false,
       :rewindable_input => true,
@@ -85,9 +84,6 @@ module Pitchfork
 
       RACKUP[:set_listener] and
         set[:listeners] << "#{RACKUP[:host]}:#{RACKUP[:port]}"
-
-      RACKUP[:no_default_middleware] and
-        set[:default_middleware] = false
     end
 
     def commit!(server, options = {}) #:nodoc:
@@ -123,14 +119,14 @@ module Pitchfork
       set[:logger] = obj
     end
 
-    def before_fork(*args, &block)
-      set_hook(:before_fork, block_given? ? block : args[0])
-    end
-
     def after_fork(*args, &block)
       set_hook(:after_fork, block_given? ? block : args[0])
     end
 
+    def after_promotion(*args, &block)
+      set_hook(:after_promotion, block_given? ? block : args[0])
+    end
+
     def after_worker_ready(*args, &block)
       set_hook(:after_worker_ready, block_given? ? block : args[0])
     end
@@ -139,10 +135,6 @@ module Pitchfork
       set_hook(:after_worker_exit, block_given? ? block : args[0], 3)
     end
 
-    def mold_selector(*args, &block)
-      set_hook(:mold_selector, block_given? ? block : args[0], 3)
-    end
-
     def timeout(seconds)
       set_int(:timeout, seconds, 3)
       # POSIX says 31 days is the smallest allowed maximum timeout for select()
@@ -154,10 +146,6 @@ module Pitchfork
       set_int(:worker_processes, nr, 1)
     end
 
-    def default_middleware(bool)
-      set_bool(:default_middleware, bool)
-    end
-
     def early_hints(bool)
       set_bool(:early_hints, bool)
     end
@@ -208,8 +196,12 @@ module Pitchfork
     # Defines the number of requests per-worker after which a new generation
     # should be spawned.
     #
+    # +false+ can be used to mark a final generation, otherwise the last request
+    # count is re-used indefinitely.
+    #
     # example:
     #.  refork_after [50, 100, 1000]
+    #.  refork_after [50, 100, 1000, false]
     #
     # Note that reforking is only available on Linux. Other Unix-like systems
     # don't have this capability.

data/lib/pitchfork/flock.rb

@@ -0,0 +1,51 @@
+require 'tempfile'
+
+module Pitchfork
+  class Flock
+    Error = Class.new(StandardError)
+
+    def initialize(name)
+      @name = name
+      @file = Tempfile.create([name, '.lock'])
+      @file.write("#{Process.pid}\n")
+      @file.flush
+      @owned = false
+    end
+
+    def at_fork
+      @owned = false
+      @file.close
+      @file = File.open(@file.path, "w")
+      nil
+    end
+
+    def unlink
+      File.unlink(@file.path)
+    rescue Errno::ENOENT
+      false
+    end
+
+    def try_lock
+      raise Error, "Pitchfork::Flock(#{@name}) trying to lock an already owned lock" if @owned
+
+      if @file.flock(File::LOCK_EX | File::LOCK_NB)
+        @owned = true
+      else
+        false
+      end
+    end
+
+    def unlock
+      raise Error, "Pitchfork::Flock(#{@name}) trying to unlock a non-owned lock" unless @owned
+
+      begin
+        if @file.flock(File::LOCK_UN)
+          @owned = false
+          true
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/pitchfork/http_server.rb

@@ -1,5 +1,6 @@
 # -*- encoding: binary -*-
 require 'pitchfork/pitchfork_http'
+require 'pitchfork/flock'
 
 module Pitchfork
   # This is the process manager of Pitchfork. This manages worker
@@ -9,11 +10,11 @@ module Pitchfork
   class HttpServer
     # :stopdoc:
     attr_accessor :app, :timeout, :worker_processes,
-                  :before_fork, :after_fork,
+                  :after_fork, :after_promotion,
                   :listener_opts, :children,
                   :orig_app, :config, :ready_pipe,
                   :default_middleware, :early_hints
-    attr_writer   :after_worker_exit, :after_worker_ready, :refork_condition, :mold_selector
+    attr_writer   :after_worker_exit, :after_worker_ready, :refork_condition
 
     attr_reader :logger
     include Pitchfork::SocketHelper
@@ -27,7 +28,6 @@ module Pitchfork
     NOOP = '.'
 
     REFORKING_AVAILABLE = Pitchfork::CHILD_SUBREAPER_AVAILABLE || Process.pid == 1
-    MAX_SLEEP = 1 # seconds
 
     # :startdoc:
     # This Hash is considered a stable interface and changing its contents
@@ -60,13 +60,15 @@ module Pitchfork
     # HttpServer.run.join to join the thread that's processing
     # incoming requests on the socket.
     def initialize(app, options = {})
+      @exit_status = 0
       @app = app
       @respawn = false
       @last_check = time_now
-      @default_middleware = true
+      @promotion_lock = Flock.new("pitchfork-promotion")
+
       options = options.dup
       @ready_pipe = options.delete(:ready_pipe)
-      @init_listeners = options[:listeners] ? options[:listeners].dup : []
+      @init_listeners = options[:listeners].dup || []
       options[:use_defaults] = true
       self.config = Pitchfork::Configurator.new(options)
       self.listener_opts = {}
@@ -104,7 +106,7 @@ module Pitchfork
     end
 
     # Runs the thing.  Returns self so you can run join on it
-    def start
+    def start(sync = true)
       Pitchfork.enable_child_subreaper # noop if not supported
 
       # This socketpair is used to wake us up from select(2) in #join when signals
@@ -120,7 +122,6 @@ module Pitchfork
       @queue_sigs.each { |sig| trap(sig) { @sig_queue << sig; awaken_master } }
       trap(:CHLD) { awaken_master }
 
-      bind_listeners!
       if REFORKING_AVAILABLE
         spawn_initial_mold
         wait_for_pending_workers
@@ -129,13 +130,17 @@ module Pitchfork
         end
       else
         build_app!
+        bind_listeners!
+        after_promotion.call(self, Worker.new(nil, pid: $$).promoted!)
       end
 
-      spawn_missing_workers
-      # We could just return here as we'd register them later in #join.
-      # However a good part of the test suite assumes #start only return
-      # once all initial workers are spawned.
-      wait_for_pending_workers
+      if sync
+        spawn_missing_workers
+        # We could just return here as we'd register them later in #join.
+        # However a good part of the test suite assumes #start only return
+        # once all initial workers are spawned.
+        wait_for_pending_workers
+      end
 
       self
     end
@@ -237,10 +242,19 @@ module Pitchfork
       end
       stop # gracefully shutdown all workers on our way out
       logger.info "master complete"
+      @exit_status
     end
 
     def monitor_loop(sleep = true)
       reap_all_workers
+
+      if REFORKING_AVAILABLE && @respawn && @children.molds.empty?
+        logger.info("No mold alive, shutting down")
+        @exit_status = 1
+        @sig_queue << :QUIT
+        @respawn = false
+      end
+
       case message = @sig_queue.shift
       when nil
         # avoid murdering workers after our master process (or the
@@ -253,13 +267,15 @@ module Pitchfork
         end
         if @respawn
           maintain_worker_count
-          automatically_refork_workers if REFORKING_AVAILABLE
+          restart_outdated_workers if REFORKING_AVAILABLE
         end
 
         master_sleep(sleep_time) if sleep
       when :QUIT # graceful shutdown
+        logger.info "QUIT received, starting graceful shutdown"
         return StopIteration
       when :TERM, :INT # immediate shutdown
+        logger.info "#{message} received, starting immediate shutdown"
         stop(false)
         return StopIteration
       when :USR2 # trigger a promotion
@@ -290,6 +306,7 @@ module Pitchfork
 
     # Terminates all workers, but does not exit master process
     def stop(graceful = true)
+      wait_for_pending_workers
       self.listeners = []
       limit = time_now + timeout
       until @children.workers.empty? || time_now > limit
@@ -302,6 +319,7 @@ module Pitchfork
         reap_all_workers
       end
       kill_each_child(:KILL)
+      @promotion_lock.unlink
     end
 
     def rewindable_input
@@ -333,8 +351,6 @@ module Pitchfork
 
     # wait for a signal handler to wake us up and then consume the pipe
     def master_sleep(sec)
-      sec = MAX_SLEEP if sec > MAX_SLEEP
-
       @control_socket[0].wait(sec) or return
       case message = @control_socket[0].recvmsg_nonblock(exception: false)
       when :wait_readable, NOOP
@@ -351,7 +367,7 @@ module Pitchfork
 
     # reaps all unreaped workers
     def reap_all_workers
-      begin
+      loop do
         wpid, status = Process.waitpid2(-1, Process::WNOHANG)
         wpid or return
         worker = @children.reap(wpid) and worker.close rescue nil
@@ -362,7 +378,7 @@ module Pitchfork
         end
       rescue Errno::ECHILD
         break
-      end while true
+      end
     end
 
     def listener_sockets
@@ -374,15 +390,6 @@ module Pitchfork
       listener_fds
     end
 
-    def close_sockets_on_exec(sockets)
-      (3..1024).each do |io|
-        next if sockets.include?(io)
-        io = IO.for_fd(io) rescue next
-        io.autoclose = false
-        io.close_on_exec = true
-      end
-    end
-
     # forcibly terminate all workers that haven't checked in in timeout seconds.  The timeout is implemented using an unlinked File
     def murder_lazy_workers
       next_sleep = @timeout - 1
@@ -413,17 +420,17 @@ module Pitchfork
       end
 
       unless @children.pending_promotion?
-        @children.refresh
-        if new_mold = @mold_selector.call(self)
+        if new_mold = @children.fresh_workers.first
           @children.promote(new_mold)
         else
-          logger.error("The mold select didn't return a candidate")
+          logger.error("No children at all???")
         end
       else
       end
     end
 
     def after_fork_internal
+      @promotion_lock.at_fork
       @control_socket[0].close_write # this is master-only, now
       @ready_pipe.close if @ready_pipe
       Pitchfork::Configurator::RACKUP.clear
@@ -435,9 +442,9 @@ module Pitchfork
     end
 
     def spawn_worker(worker, detach:)
-      before_fork.call(self, worker)
+      logger.info("worker=#{worker.nr} gen=#{worker.generation} spawning...")
 
-      pid = fork do
+      pid = Pitchfork.clean_fork do
         # We double fork so that the new worker is re-attached back
         # to the master.
         # This requires either PR_SET_CHILD_SUBREAPER which is exclusive to Linux 3.4
@@ -467,10 +474,11 @@ module Pitchfork
     def spawn_initial_mold
       mold = Worker.new(nil)
       mold.create_socketpair!
-      mold.pid = fork do
-        after_fork_internal
+      mold.pid = Pitchfork.clean_fork do
+        @promotion_lock.try_lock
         mold.after_fork_in_child
         build_app!
+        bind_listeners!
         mold_loop(mold)
       end
       @children.register_mold(mold)
@@ -484,9 +492,11 @@ module Pitchfork
         end
         worker = Pitchfork::Worker.new(worker_nr)
 
-        if !@children.mold || !@children.mold.spawn_worker(worker)
-          # If there's no mold, or the mold was somehow unreachable
-          # we fallback to spawning the missing workers ourselves.
+        if REFORKING_AVAILABLE
+          unless @children.mold&.spawn_worker(worker)
+            @logger.error("Failed to send a spawn_woker command")
+          end
+        else
           spawn_worker(worker, detach: false)
         end
         # We could directly register workers when we spawn from the
@@ -504,7 +514,7 @@ module Pitchfork
       while @children.pending_workers?
         master_sleep(0.5)
         if monitor_loop(false) == StopIteration
-          break
+          return StopIteration
         end
       end
     end
@@ -515,34 +525,21 @@ module Pitchfork
       @children.each_worker { |w| w.nr >= worker_processes and w.soft_kill(:QUIT) }
     end
 
-    def automatically_refork_workers
+    def restart_outdated_workers
       # If we're already in the middle of forking a new generation, we just continue
-      if @children.mold
-        # We don't shutdown any outdated worker if any worker is already being spawned
-        # or a worker is exiting. Workers are only reforked one by one to minimize the
-        # impact on capacity.
-        # In the future we may want to use a dynamic limit, e.g. 10% of workers may be down at
-        # a time.
-        return if @children.pending_workers?
-        return if @children.workers.any?(&:exiting?)
-
-        if outdated_worker = @children.workers.find { |w| w.generation < @children.mold.generation }
-          logger.info("worker=#{outdated_worker.nr} pid=#{outdated_worker.pid} restarting")
-          outdated_worker.soft_kill(:QUIT)
-          return # That's all folks
-        end
-      end
-
-      # If all workers are alive and well, we can consider reforking a new generation
-      if @refork_condition
-        @children.refresh
-        if @refork_condition.met?(@children, logger)
-          logger.info("Refork condition met, scheduling a promotion")
-          unless @sig_queue.include?(:USR2)
-            @sig_queue << :USR2
-            awaken_master
-          end
-        end
+      return unless @children.mold
+
+      # We don't shutdown any outdated worker if any worker is already being spawned
+      # or a worker is exiting. Workers are only reforked one by one to minimize the
+      # impact on capacity.
+      # In the future we may want to use a dynamic limit, e.g. 10% of workers may be down at
+      # a time.
+      return if @children.pending_workers?
+      return if @children.workers.any?(&:exiting?)
+
+      if outdated_worker = @children.workers.find { |w| w.generation < @children.mold.generation }
+        logger.info("worker=#{outdated_worker.nr} pid=#{outdated_worker.pid} restarting")
+        outdated_worker.soft_kill(:QUIT)
       end
     end
 
@@ -667,6 +664,7 @@ module Pitchfork
 
     def init_mold_process(worker)
       proc_name "mold (gen: #{worker.generation})"
+      after_promotion.call(self, worker)
       readers = [worker]
       trap(:QUIT) { nuke_listeners!(readers) }
       readers
@@ -702,6 +700,12 @@ module Pitchfork
           client = false if client == :wait_readable
           if client
             case client
+            when Message::PromoteWorker
+              if @promotion_lock.try_lock
+                logger.info("Refork asked by master, promoting ourselves")
+                worker.tick = time_now.to_i
+                return worker.promoted!
+              end
             when Message
               worker.update(client)
             else
@@ -710,11 +714,21 @@ module Pitchfork
             end
             worker.tick = time_now.to_i
           end
-          return if worker.mold? # We've been promoted we can exit the loop
         end
 
         # timeout so we can .tick and keep parent from SIGKILL-ing us
         worker.tick = time_now.to_i
+        if @refork_condition && !worker.outdated?
+          if @refork_condition.met?(worker, logger)
+            if @promotion_lock.try_lock
+              logger.info("Refork condition met, promoting ourselves")
+              return worker.promote! # We've been promoted we can exit the loop
+            else
+              # TODO: if we couldn't acquire the lock, we should backoff the refork_condition to avoid hammering the lock
+            end
+          end
+        end
+
         waiter.get_readers(ready, readers, @timeout * 500) # to milliseconds, but halved
       rescue => e
         Pitchfork.log_error(@logger, "listen loop error", e) if readers[0]
@@ -724,10 +738,9 @@ module Pitchfork
     def mold_loop(mold)
       readers = init_mold_process(mold)
       waiter = prep_readers(readers)
-      mold.acknowlege_promotion(@control_socket[1])
-
+      mold.declare_promotion(@control_socket[1])
+      @promotion_lock.unlock
       ready = readers.dup
-      # TODO: mold ready callback?
 
       begin
         mold.tick = time_now.to_i
@@ -739,7 +752,11 @@ module Pitchfork
           when false
             # no message, keep looping
           when Message::SpawnWorker
-            spawn_worker(Worker.new(message.nr, generation: mold.generation), detach: true)
+            begin
+              spawn_worker(Worker.new(message.nr, generation: mold.generation), detach: true)
+            rescue => error
+              raise BootFailure, error.message
+            end
           else
             logger.error("Unexpected mold message #{message.inspect}")
           end
@@ -749,7 +766,7 @@ module Pitchfork
         mold.tick = time_now.to_i
         waiter.get_readers(ready, readers, @timeout * 500) # to milliseconds, but halved
       rescue => e
-        Pitchfork.log_error(@logger, "listen loop error", e) if readers[0]
+        Pitchfork.log_error(@logger, "mold loop error", e) if readers[0]
       end while readers[0]
     end
 

data/lib/pitchfork/refork_condition.rb

@@ -7,9 +7,9 @@ module Pitchfork
         @limits = request_counts
       end
 
-      def met?(children, logger)
-        if limit = @limits[children.last_generation]
-          if worker = children.fresh_workers.find { |w| w.requests_count >= limit }
+      def met?(worker, logger)
+        if limit = @limits.fetch(worker.generation) { @limits.last }
+          if worker.requests_count >= limit
             logger.info("worker=#{worker.nr} pid=#{worker.pid} processed #{worker.requests_count} requests, triggering a refork")
             return true
           end

data/lib/pitchfork/version.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Pitchfork
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
   module Const
     UNICORN_VERSION = '6.1.0'
   end