precompiled-raindrops 0.18.0

data/ext/raindrops/tcp_info.c

@@ -0,0 +1,245 @@
+#include <ruby.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#if defined(HAVE_LINUX_TCP_H)
+#  include <linux/tcp.h>
+#else
+#  if defined(HAVE_NETINET_TCP_H)
+#    include <netinet/tcp.h>
+#  endif
+#  if defined(HAVE_NETINET_TCP_FSM_H)
+#    include <netinet/tcp_fsm.h>
+#  endif
+#endif
+
+#ifdef HAVE_TYPE_STRUCT_TCP_INFO
+#include "my_fileno.h"
+
+CFUNC_tcp_info_tcpi_state
+CFUNC_tcp_info_tcpi_ca_state
+CFUNC_tcp_info_tcpi_retransmits
+CFUNC_tcp_info_tcpi_probes
+CFUNC_tcp_info_tcpi_backoff
+CFUNC_tcp_info_tcpi_options
+CFUNC_tcp_info_tcpi_snd_wscale
+CFUNC_tcp_info_tcpi_rcv_wscale
+CFUNC_tcp_info_tcpi_rto
+CFUNC_tcp_info_tcpi_ato
+CFUNC_tcp_info_tcpi_snd_mss
+CFUNC_tcp_info_tcpi_rcv_mss
+CFUNC_tcp_info_tcpi_unacked
+CFUNC_tcp_info_tcpi_sacked
+CFUNC_tcp_info_tcpi_lost
+CFUNC_tcp_info_tcpi_retrans
+CFUNC_tcp_info_tcpi_fackets
+CFUNC_tcp_info_tcpi_last_data_sent
+CFUNC_tcp_info_tcpi_last_ack_sent
+CFUNC_tcp_info_tcpi_last_data_recv
+CFUNC_tcp_info_tcpi_last_ack_recv
+CFUNC_tcp_info_tcpi_pmtu
+CFUNC_tcp_info_tcpi_rcv_ssthresh
+CFUNC_tcp_info_tcpi_rtt
+CFUNC_tcp_info_tcpi_rttvar
+CFUNC_tcp_info_tcpi_snd_ssthresh
+CFUNC_tcp_info_tcpi_snd_cwnd
+CFUNC_tcp_info_tcpi_advmss
+CFUNC_tcp_info_tcpi_reordering
+CFUNC_tcp_info_tcpi_rcv_rtt
+CFUNC_tcp_info_tcpi_rcv_space
+CFUNC_tcp_info_tcpi_total_retrans
+
+static size_t tcpi_memsize(const void *ptr)
+{
+	return sizeof(struct tcp_info);
+}
+
+static const rb_data_type_t tcpi_type = {
+	"tcp_info",
+	{ NULL, RUBY_TYPED_DEFAULT_FREE, tcpi_memsize, /* reserved */ },
+	/* parent, data, [ flags ] */
+};
+
+static VALUE alloc(VALUE klass)
+{
+	struct tcp_info *info;
+
+	return TypedData_Make_Struct(klass, struct tcp_info, &tcpi_type, info);
+}
+
+/*
+ * call-seq:
+ *
+ *	Raindrops::TCP_Info.new(tcp_socket)	-> TCP_Info object
+ *
+ * Reads a TCP_Info object from any given +tcp_socket+.  See the tcp(7)
+ * manpage and /usr/include/linux/tcp.h for more details.
+ */
+static VALUE init(VALUE self, VALUE io)
+{
+	int fd = my_fileno(rb_io_get_io(io));
+	struct tcp_info *info = DATA_PTR(self);
+	socklen_t len = (socklen_t)sizeof(struct tcp_info);
+	int rc = getsockopt(fd, IPPROTO_TCP, TCP_INFO, info, &len);
+
+	if (rc != 0)
+		rb_sys_fail("getsockopt");
+
+	return self;
+}
+
+void Init_raindrops_tcp_info(void)
+{
+	VALUE cRaindrops = rb_define_class("Raindrops", rb_cObject);
+	VALUE cTCP_Info;
+
+	/*
+	 * Document-class: Raindrops::TCP_Info
+	 *
+	 * This is used to wrap "struct tcp_info" as described in tcp(7)
+	 * and /usr/include/linux/tcp.h.  The following readers methods
+	 * are defined corresponding to the "tcpi_" fields in the
+	 * tcp_info struct.
+	 *
+	 * As of raindrops 0.18.0+, this is supported on FreeBSD and OpenBSD
+	 * systems as well as Linux, although not all fields exist or
+	 * match the documentation, below.
+	 *
+	 * In particular, the +last_data_recv+ field is useful for measuring
+	 * the amount of time a client spent in the listen queue before
+	 * +accept()+, but only if +TCP_DEFER_ACCEPT+ is used with the
+	 * listen socket (it is on by default in Unicorn).
+	 *
+	 * - state
+	 * - ca_state
+	 * - retransmits
+	 * - probes
+	 * - backoff
+	 * - options
+	 * - snd_wscale
+	 * - rcv_wscale
+	 * - rto
+	 * - ato
+	 * - snd_mss
+	 * - rcv_mss
+	 * - unacked
+	 * - sacked
+	 * - lost
+	 * - retrans
+	 * - fackets
+	 * - last_data_sent
+	 * - last_ack_sent
+	 * - last_data_recv
+	 * - last_ack_recv
+	 * - pmtu
+	 * - rcv_ssthresh
+	 * - rtt
+	 * - rttvar
+	 * - snd_ssthresh
+	 * - snd_cwnd
+	 * - advmss
+	 * - reordering
+	 * - rcv_rtt
+	 * - rcv_space
+	 * - total_retrans
+	 *
+	 * https://kernel.org/doc/man-pages/online/pages/man7/tcp.7.html
+	 */
+	cTCP_Info = rb_define_class_under(cRaindrops, "TCP_Info", rb_cObject);
+	rb_define_alloc_func(cTCP_Info, alloc);
+	rb_define_private_method(cTCP_Info, "initialize", init, 1);
+
+	/*
+	 * Document-method: Raindrops::TCP_Info#get!
+	 *
+	 * call-seq:
+	 *
+	 *	info = Raindrops::TCP_Info.new(tcp_socket)
+	 *	info.get!(tcp_socket)
+	 *
+	 * Update an existing TCP_Info objects with the latest stats
+	 * from the given socket.  This even allows sharing TCP_Info
+	 * objects between different sockets to avoid garbage.
+	 */
+	rb_define_method(cTCP_Info, "get!", init, 1);
+
+	DEFINE_METHOD_tcp_info_tcpi_state;
+	DEFINE_METHOD_tcp_info_tcpi_ca_state;
+	DEFINE_METHOD_tcp_info_tcpi_retransmits;
+	DEFINE_METHOD_tcp_info_tcpi_probes;
+	DEFINE_METHOD_tcp_info_tcpi_backoff;
+	DEFINE_METHOD_tcp_info_tcpi_options;
+	DEFINE_METHOD_tcp_info_tcpi_snd_wscale;
+	DEFINE_METHOD_tcp_info_tcpi_rcv_wscale;
+	DEFINE_METHOD_tcp_info_tcpi_rto;
+	DEFINE_METHOD_tcp_info_tcpi_ato;
+	DEFINE_METHOD_tcp_info_tcpi_snd_mss;
+	DEFINE_METHOD_tcp_info_tcpi_rcv_mss;
+	DEFINE_METHOD_tcp_info_tcpi_unacked;
+	DEFINE_METHOD_tcp_info_tcpi_sacked;
+	DEFINE_METHOD_tcp_info_tcpi_lost;
+	DEFINE_METHOD_tcp_info_tcpi_retrans;
+	DEFINE_METHOD_tcp_info_tcpi_fackets;
+	DEFINE_METHOD_tcp_info_tcpi_last_data_sent;
+	DEFINE_METHOD_tcp_info_tcpi_last_ack_sent;
+	DEFINE_METHOD_tcp_info_tcpi_last_data_recv;
+	DEFINE_METHOD_tcp_info_tcpi_last_ack_recv;
+	DEFINE_METHOD_tcp_info_tcpi_pmtu;
+	DEFINE_METHOD_tcp_info_tcpi_rcv_ssthresh;
+	DEFINE_METHOD_tcp_info_tcpi_rtt;
+	DEFINE_METHOD_tcp_info_tcpi_rttvar;
+	DEFINE_METHOD_tcp_info_tcpi_snd_ssthresh;
+	DEFINE_METHOD_tcp_info_tcpi_snd_cwnd;
+	DEFINE_METHOD_tcp_info_tcpi_advmss;
+	DEFINE_METHOD_tcp_info_tcpi_reordering;
+	DEFINE_METHOD_tcp_info_tcpi_rcv_rtt;
+	DEFINE_METHOD_tcp_info_tcpi_rcv_space;
+	DEFINE_METHOD_tcp_info_tcpi_total_retrans;
+
+#ifdef RAINDROPS_TCP_STATES_ALL_KNOWN
+
+	/*
+	 * Document-const: Raindrops::TCP
+         *
+         * This is a frozen hash storing the numeric values
+         * maps platform-independent symbol keys to
+         * platform-dependent numeric values. These states
+         * are all valid values for the Raindrops::TCP_Info#state field.
+         *
+         * The platform-independent names of the keys in this hash are:
+         *
+         *  - :ESTABLISHED
+         *  - :SYN_SENT
+         *  - :SYN_RECV
+         *  - :FIN_WAIT1
+         *  - :FIN_WAIT2
+         *  - :TIME_WAIT
+         *  - :CLOSE
+         *  - :CLOSE_WAIT
+         *  - :LAST_ACK
+         *  - :LISTEN
+         *  - :CLOSING
+         *
+         * This is only supported on platforms where TCP_Info is supported,
+         * currently FreeBSD, OpenBSD, and Linux-based systems.
+         */
+	{
+#define TCPSET(n,v) rb_hash_aset(tcp, ID2SYM(rb_intern(#n)), INT2NUM(v))
+		VALUE tcp = rb_hash_new();
+		TCPSET(ESTABLISHED, RAINDROPS_TCP_ESTABLISHED);
+		TCPSET(SYN_SENT, RAINDROPS_TCP_SYN_SENT);
+		TCPSET(SYN_RECV, RAINDROPS_TCP_SYN_RECV);
+		TCPSET(FIN_WAIT1, RAINDROPS_TCP_FIN_WAIT1);
+		TCPSET(FIN_WAIT2, RAINDROPS_TCP_FIN_WAIT2);
+		TCPSET(TIME_WAIT, RAINDROPS_TCP_TIME_WAIT);
+		TCPSET(CLOSE, RAINDROPS_TCP_CLOSE);
+		TCPSET(CLOSE_WAIT, RAINDROPS_TCP_CLOSE_WAIT);
+		TCPSET(LAST_ACK, RAINDROPS_TCP_LAST_ACK);
+		TCPSET(LISTEN, RAINDROPS_TCP_LISTEN);
+		TCPSET(CLOSING, RAINDROPS_TCP_CLOSING);
+#undef TCPSET
+		OBJ_FREEZE(tcp);
+		rb_define_const(cRaindrops, "TCP", tcp);
+	}
+#endif
+}
+#endif /* HAVE_STRUCT_TCP_INFO */

data/lib/raindrops/aggregate/last_data_recv.rb

@@ -0,0 +1,95 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+require "socket"
+#
+#
+# This module is used to extend TCPServer and Kgio::TCPServer objects
+# and aggregate +last_data_recv+ times for all accepted clients. It
+# is designed to be used with Raindrops::LastDataRecv Rack application
+# but can be easily changed to work with other stats collection devices.
+#
+# Methods wrapped include:
+# - TCPServer#accept
+# - TCPServer#accept_nonblock
+# - Socket#accept
+# - Socket#accept_nonblock
+# - Kgio::TCPServer#kgio_accept
+# - Kgio::TCPServer#kgio_tryaccept
+module Raindrops::Aggregate::LastDataRecv
+  # The integer value of +last_data_recv+ is sent to this object.
+  # This is usually a duck type compatible with the \Aggregate class,
+  # but can be *anything* that accepts the *<<* method.
+  attr_accessor :raindrops_aggregate
+
+  @@default_aggregate = nil
+
+  # By default, this is a Raindrops::Aggregate::PMQ object
+  # It may be anything that responds to *<<*
+  def self.default_aggregate
+    @@default_aggregate ||= Raindrops::Aggregate::PMQ.new
+  end
+
+  # Assign any object that responds to *<<*
+  def self.default_aggregate=(agg)
+    @@default_aggregate = agg
+  end
+
+  # automatically extends any TCPServer objects used by Unicorn
+  def self.cornify!
+    Unicorn::HttpServer::LISTENERS.each do |s|
+      if TCPServer === s || (s.instance_of?(Socket) && s.local_address.ip?)
+        s.extend(self)
+      end
+    end
+  end
+
+  # each extended object needs to have TCP_DEFER_ACCEPT enabled
+  # for accuracy.
+  def self.extended(obj)
+    obj.raindrops_aggregate = default_aggregate
+    # obj.setsockopt Socket::SOL_TCP, tcp_defer_accept = 9, seconds = 60
+    obj.setsockopt Socket::SOL_TCP, 9, 60
+  end
+
+  # :stopdoc:
+
+  def kgio_tryaccept(*args)
+    count! super
+  end
+
+  def kgio_accept(*args)
+    count! super
+  end
+
+  def accept
+    count! super
+  end
+
+  def accept_nonblock(exception: true)
+    count! super(exception: exception)
+  end
+
+  # :startdoc:
+
+  # The +last_data_recv+ member of Raindrops::TCP_Info can be used to
+  # infer the time a client spent in the listen queue before it was
+  # accepted.
+  #
+  # We require TCP_DEFER_ACCEPT on the listen socket for
+  # +last_data_recv+ to be accurate
+  def count!(ret)
+    case ret
+    when :wait_readable
+    when Array # Socket#accept_nonblock
+      io = ret[0]
+    else # TCPSocket#accept_nonblock
+      io = ret
+    end
+    if io
+      x = Raindrops::TCP_Info.new(io)
+      @raindrops_aggregate << x.last_data_recv
+    end
+    ret
+  end
+end
+

data/lib/raindrops/aggregate/pmq.rb

@@ -0,0 +1,246 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+require "tempfile"
+require "aggregate"
+require "posix_mq"
+require "fcntl"
+require "thread"
+require "stringio"
+
+# \Aggregate + POSIX message queues support for Ruby 1.9+ and \Linux
+#
+# This class is duck-type compatible with \Aggregate and allows us to
+# aggregate and share statistics from multiple processes/threads aided
+# POSIX message queues.  This is designed to be used with the
+# Raindrops::LastDataRecv Rack application, but can be used independently
+# on compatible Runtimes.
+#
+# Unlike the core of raindrops, this is only supported on Ruby 1.9+ and
+# Linux 2.6+.  Using this class requires the following additional RubyGems
+# or libraries:
+#
+# * aggregate (tested with 0.2.2)
+# * posix_mq  (tested with 1.0.0)
+#
+# == Design
+#
+# There is one master thread which aggregates statistics.  Individual
+# worker processes or threads will write to a shared POSIX message
+# queue (default: "/raindrops") that the master reads from.  At a
+# predefined interval, the master thread will write out to a shared,
+# anonymous temporary file that workers may read from
+#
+# Setting +:worker_interval+ and +:master_interval+ to +1+ will result
+# in perfect accuracy but at the cost of a high synchronization
+# overhead.  Larger intervals mean less frequent messaging for higher
+# performance but lower accuracy.
+class Raindrops::Aggregate::PMQ
+
+  # :stopdoc:
+  # These constants are for Linux.  This is designed for aggregating
+  # TCP_INFO.
+  RDLOCK = [ Fcntl::F_RDLCK ].pack("s @256".freeze).freeze
+  WRLOCK = [ Fcntl::F_WRLCK ].pack("s @256".freeze).freeze
+  UNLOCK = [ Fcntl::F_UNLCK ].pack("s @256".freeze).freeze
+  # :startdoc:
+
+  # returns the number of dropped messages sent to a POSIX message
+  # queue if non-blocking operation was desired with :lossy
+  attr_reader :nr_dropped
+
+  #
+  # Creates a new Raindrops::Aggregate::PMQ object
+  #
+  #   Raindrops::Aggregate::PMQ.new(options = {})  -> aggregate
+  #
+  # +options+ is a hash that accepts the following keys:
+  #
+  # * :queue - name of the POSIX message queue (default: "/raindrops")
+  # * :worker_interval - interval to send to the master (default: 10)
+  # * :master_interval - interval to for the master to write out (default: 5)
+  # * :lossy - workers drop packets if master cannot keep up (default: false)
+  # * :aggregate - \Aggregate object (default: \Aggregate.new)
+  # * :mq_umask - umask for creatingthe POSIX message queue (default: 0666)
+  #
+  def initialize(params = {})
+    opts = {
+      :queue => ENV["RAINDROPS_MQUEUE"] || "/raindrops",
+      :worker_interval => 10,
+      :master_interval => 5,
+      :lossy => false,
+      :mq_attr => nil,
+      :mq_umask => 0666,
+      :aggregate => Aggregate.new,
+    }.merge! params
+    @master_interval = opts[:master_interval]
+    @worker_interval = opts[:worker_interval]
+    @aggregate = opts[:aggregate]
+    @worker_queue = @worker_interval ? [] : nil
+    @mutex = Mutex.new
+
+    @mq_name = opts[:queue]
+    mq = POSIX_MQ.new @mq_name, :w, opts[:mq_umask], opts[:mq_attr]
+    Tempfile.open("raindrops_pmq") do |t|
+      @wr = File.open(t.path, "wb")
+      @rd = File.open(t.path, "rb")
+    end
+    @wr.sync = true
+    @cached_aggregate = @aggregate
+    flush_master
+    @mq_send = if opts[:lossy]
+      @nr_dropped = 0
+      mq.nonblock = true
+      mq.method :trysend
+    else
+      mq.method :send
+    end
+  end
+
+  # adds a sample to the underlying \Aggregate object
+  def << val
+    if q = @worker_queue
+      q << val
+      if q.size >= @worker_interval
+        mq_send(q) or @nr_dropped += 1
+        q.clear
+      end
+    else
+      mq_send(val) or @nr_dropped += 1
+    end
+  end
+
+  def mq_send(val) # :nodoc:
+    @cached_aggregate = nil
+    @mq_send.call Marshal.dump(val)
+  end
+
+  #
+  # Starts running a master loop, usually in a dedicated thread or process:
+  #
+  #   Thread.new { agg.master_loop }
+  #
+  # Any worker can call +agg.stop_master_loop+ to stop the master loop
+  # (possibly causing the thread or process to exit)
+  def master_loop
+    buf = ""
+    a = @aggregate
+    nr = 0
+    mq = POSIX_MQ.new @mq_name, :r # this one is always blocking
+    begin
+      if (nr -= 1) < 0
+        nr = @master_interval
+        flush_master
+      end
+      mq.shift(buf)
+      data = begin
+        Marshal.load(buf) or return
+      rescue ArgumentError, TypeError
+        next
+      end
+      Array === data ? data.each { |x| a << x } : a << data
+    rescue Errno::EINTR
+    rescue => e
+      warn "Unhandled exception in #{__FILE__}:#{__LINE__}: #{e}"
+      break
+    end while true
+  ensure
+    flush_master
+  end
+
+  # Loads the last shared \Aggregate from the master thread/process
+  def aggregate
+    @cached_aggregate ||= begin
+      flush
+      Marshal.load(synchronize(@rd, RDLOCK) do |rd|
+        dst = StringIO.new
+        dst.binmode
+        IO.copy_stream(rd, dst, rd.size, 0)
+        dst.string
+      end)
+    end
+  end
+
+  # Flushes the currently aggregate statistics to a temporary file.
+  # There is no need to call this explicitly as +:worker_interval+ defines
+  # how frequently your data will be flushed for workers to read.
+  def flush_master
+    dump = Marshal.dump @aggregate
+    synchronize(@wr, WRLOCK) do |wr|
+      wr.truncate 0
+      wr.rewind
+      wr.write(dump)
+    end
+  end
+
+  # stops the currently running master loop, may be called from any
+  # worker thread or process
+  def stop_master_loop
+    sleep 0.1 until mq_send(false)
+  rescue Errno::EINTR
+    retry
+  end
+
+  def lock! io, type # :nodoc:
+    io.fcntl Fcntl::F_SETLKW, type
+  rescue Errno::EINTR
+    retry
+  end
+
+  # we use both a mutex for thread-safety and fcntl lock for process-safety
+  def synchronize io, type # :nodoc:
+    @mutex.synchronize do
+      begin
+        type = type.dup
+        lock! io, type
+        yield io
+      ensure
+        lock! io, type.replace(UNLOCK)
+        type.clear
+      end
+    end
+  end
+
+  # flushes the local queue of the worker process, sending all pending
+  # data to the master.  There is no need to call this explicitly as
+  # +:worker_interval+ defines how frequently your queue will be flushed
+  def flush
+    if q = @local_queue && ! q.empty?
+      mq_send q
+      q.clear
+    end
+    nil
+  end
+
+  # proxy for \Aggregate#count
+  def count; aggregate.count; end
+
+  # proxy for \Aggregate#max
+  def max; aggregate.max; end
+
+  # proxy for \Aggregate#min
+  def min; aggregate.min; end
+
+  # proxy for \Aggregate#sum
+  def sum; aggregate.sum; end
+
+  # proxy for \Aggregate#mean
+  def mean; aggregate.mean; end
+
+  # proxy for \Aggregate#std_dev
+  def std_dev; aggregate.std_dev; end
+
+  # proxy for \Aggregate#outliers_low
+  def outliers_low; aggregate.outliers_low; end
+
+  # proxy for \Aggregate#outliers_high
+  def outliers_high; aggregate.outliers_high; end
+
+  # proxy for \Aggregate#to_s
+  def to_s(*args); aggregate.to_s(*args); end
+
+  # proxy for \Aggregate#each
+  def each; aggregate.each { |*args| yield(*args) }; end
+
+  # proxy for \Aggregate#each_nonzero
+  def each_nonzero; aggregate.each_nonzero { |*args| yield(*args) }; end
+end

data/lib/raindrops/aggregate.rb

@@ -0,0 +1,9 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+#
+# raindrops may use the {aggregate}[https://github.com/josephruscio/aggregate]
+# RubyGem to aggregate statistics from TCP_Info lookups.
+module Raindrops::Aggregate
+  autoload :PMQ, "raindrops/aggregate/pmq"
+  autoload :LastDataRecv, "raindrops/aggregate/last_data_recv"
+end

data/lib/raindrops/last_data_recv.rb

@@ -0,0 +1,103 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+require "raindrops"
+
+# This is highly experimental!
+#
+# A self-contained Rack application for aggregating in the
+# +tcpi_last_data_recv+ field in +struct+ +tcp_info+ defined in
+# +/usr/include/linux/tcp.h+.  This is only useful for \Linux 2.6 and later.
+# This primarily supports Unicorn and derived servers, but may also be
+# used with any Ruby web server using the core TCPServer class in Ruby.
+#
+# Hitting the Rack endpoint configured for this application will return
+# a an ASCII histogram response body with the following headers:
+#
+# - X-Count   - number of requests received
+#
+# The following headers are only present if X-Count is greater than one.
+#
+# - X-Min     - lowest last_data_recv time recorded (in milliseconds)
+# - X-Max     - highest last_data_recv time recorded (in milliseconds)
+# - X-Mean    - mean last_data_recv time recorded (rounded, in milliseconds)
+# - X-Std-Dev - standard deviation of last_data_recv times
+# - X-Outliers-Low - number of low outliers (hopefully many!)
+# - X-Outliers-High - number of high outliers (hopefully zero!)
+#
+# == To use with Unicorn and derived servers (preload_app=false):
+#
+# Put the following in our Unicorn config file (not config.ru):
+#
+#   require "raindrops/last_data_recv"
+#
+# Then follow the instructions below for config.ru:
+#
+# == To use with any Rack server using TCPServer
+#
+# Setup a route for Raindrops::LastDataRecv in your Rackup config file
+# (typically config.ru):
+#
+#   require "raindrops"
+#   map "/raindrops/last_data_recv" do
+#     run Raindrops::LastDataRecv.new
+#   end
+#   map "/" do
+#     use SomeMiddleware
+#     use MoreMiddleware
+#     # ...
+#     run YourAppHere.new
+#   end
+#
+# == To use with any other Ruby web server that uses TCPServer
+#
+# Put the following in any piece of Ruby code loaded after the server has
+# bound its TCP listeners:
+#
+#   ObjectSpace.each_object(TCPServer) do |s|
+#     s.extend Raindrops::Aggregate::LastDataRecv
+#   end
+#
+#   Thread.new do
+#     Raindrops::Aggregate::LastDataRecv.default_aggregate.master_loop
+#   end
+#
+# Then follow the above instructions for config.ru
+#
+class Raindrops::LastDataRecv
+  # :stopdoc:
+
+  # trigger autoloads
+  if defined?(Unicorn)
+    agg = Raindrops::Aggregate::LastDataRecv.default_aggregate
+    AGGREGATE_THREAD = Thread.new { agg.master_loop }
+  end
+  # :startdoc
+
+  def initialize(opts = {})
+    if defined?(Unicorn::HttpServer::LISTENERS)
+      Raindrops::Aggregate::LastDataRecv.cornify!
+    end
+    @aggregate =
+      opts[:aggregate] || Raindrops::Aggregate::LastDataRecv.default_aggregate
+  end
+
+  def call(_)
+    a = @aggregate
+    count = a.count
+    headers = {
+      "Content-Type" => "text/plain",
+      "X-Count" => count.to_s,
+    }
+    if count > 1
+      headers["X-Min"] = a.min.to_s
+      headers["X-Max"] = a.max.to_s
+      headers["X-Mean"] = a.mean.round.to_s
+      headers["X-Std-Dev"] = a.std_dev.round.to_s
+      headers["X-Outliers-Low"] = a.outliers_low.to_s
+      headers["X-Outliers-High"] = a.outliers_high.to_s
+    end
+    body = a.to_s
+    headers["Content-Length"] = body.size.to_s
+    [ 200, headers, [ body ] ]
+  end
+end