precompiled-raindrops 0.18.0

data/lib/raindrops/linux.rb

@@ -0,0 +1,78 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+
+# For reporting TCP ListenStats, users of older \Linux kernels need to ensure
+# that the the "inet_diag" and "tcp_diag" kernel modules are loaded as they do
+# not autoload correctly.  The inet_diag facilities of \Raindrops is useful
+# for periodic snapshot reporting of listen queue sizes.
+#
+# Instead of snapshotting, Raindrops::Aggregate::LastDataRecv may be used
+# to aggregate statistics from +all+ accepted sockets as they arrive
+# based on the +last_data_recv+ field in Raindrops::TCP_Info
+
+module Raindrops::Linux
+
+  # The standard proc path for active UNIX domain sockets, feel free to call
+  # String#replace on this if your /proc is mounted in a non-standard location
+  # for whatever reason
+  PROC_NET_UNIX_ARGS = [ '/proc/net/unix', { encoding: "binary" }]
+
+  # Get ListenStats from an array of +paths+
+  #
+  # Socket state mapping from integer => symbol, based on socket_state
+  # enum from include/linux/net.h in the \Linux kernel:
+  #     typedef enum {
+  #             SS_FREE = 0,              /* not allocated                */
+  #             SS_UNCONNECTED,           /* unconnected to any socket    */
+  #             SS_CONNECTING,            /* in process of connecting     */
+  #             SS_CONNECTED,             /* connected to socket          */
+  #             SS_DISCONNECTING          /* in process of disconnecting  */
+  #     } socket_state;
+  # * SS_CONNECTING maps to ListenStats#queued
+  # * SS_CONNECTED maps to ListenStats#active
+  #
+  # This method may be significantly slower than its tcp_listener_stats
+  # counterpart due to the latter being able to use inet_diag via netlink.
+  # This parses /proc/net/unix as there is no other (known) way
+  # to expose Unix domain socket statistics over netlink.
+  def unix_listener_stats(paths = nil)
+    rv = Hash.new { |h,k| h[k.freeze] = Raindrops::ListenStats.new(0, 0) }
+    if nil == paths
+      paths = [ '[^\n]+' ]
+    else
+      paths = paths.map do |path|
+        path = path.dup
+        path.force_encoding(Encoding::BINARY)
+        if File.symlink?(path)
+          link = path
+          path = File.readlink(link)
+          path.force_encoding(Encoding::BINARY)
+          rv[link] = rv[path] # vivify ListenerStats
+        else
+          rv[path] # vivify ListenerStats
+        end
+        Regexp.escape(path)
+      end
+    end
+    paths = /^\w+: \d+ \d+ (\d+) \d+ (\d+)\s+\d+ (#{paths.join('|')})$/n
+
+    # no point in pread since we can't stat for size on this file
+    File.read(PROC_NET_UNIX_ARGS[0], encoding: 'binary').scan(paths) do |s|
+      path = s[-1]
+      case s[0]
+      when "00000000" # client sockets
+        case s[1].to_i
+        when 2 then rv[path].queued += 1
+        when 3 then rv[path].active += 1
+        end
+      else
+        # listeners, vivify empty stats
+        rv[path]
+      end
+    end
+
+    rv
+  end
+  module_function :unix_listener_stats
+
+end # Raindrops::Linux

data/lib/raindrops/middleware/proxy.rb

@@ -0,0 +1,41 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+# :stopdoc:
+# This class is used by Raindrops::Middleware to proxy application
+# response bodies.  There should be no need to use it directly.
+class Raindrops::Middleware::Proxy
+  def initialize(body, stats)
+    @body, @stats = body, stats
+  end
+
+  # yield to the Rack server here for writing
+  def each
+    @body.each { |x| yield x }
+  end
+
+  # the Rack server should call this after #each (usually ensure-d)
+  def close
+    @stats.decr_writing
+    @body.close if @body.respond_to?(:close)
+  end
+
+  # Some Rack servers can optimize response processing if it responds
+  # to +to_path+ via the sendfile(2) system call, we proxy +to_path+
+  # to the underlying body if possible.
+  def to_path
+    @body.to_path
+  end
+
+  # Rack servers use +respond_to?+ to check for the presence of +close+
+  # and +to_path+ methods.
+  def respond_to?(m, include_all = false)
+    m = m.to_sym
+    :close == m || @body.respond_to?(m, include_all)
+  end
+
+  # Avoid breaking users of non-standard extensions (e.g. #body)
+  # Rack::BodyProxy does the same.
+  def method_missing(*args, &block)
+    @body.__send__(*args, &block)
+  end
+end

data/lib/raindrops/middleware.rb

@@ -0,0 +1,154 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+require 'raindrops'
+require 'thread'
+
+# Raindrops::Middleware is Rack middleware that allows snapshotting
+# current activity from an HTTP request.  For all operating systems,
+# it returns at least the following fields:
+#
+# * calling - the number of application dispatchers on your machine
+# * writing - the number of clients being written to on your machine
+#
+# Additional fields are available for \Linux users.
+#
+# It should be loaded at the top of Rack middleware stack before other
+# middlewares for maximum accuracy.
+#
+# === Usage (Rainbows!/Unicorn preload_app=false)
+#
+# If you're using preload_app=false (the default) in your Rainbows!/Unicorn
+# config file, you'll need to create the global Stats object before
+# forking.
+#
+#    require 'raindrops'
+#    $stats ||= Raindrops::Middleware::Stats.new
+#
+# In your Rack config.ru:
+#
+#    use Raindrops::Middleware, :stats => $stats
+#
+# === Usage (Rainbows!/Unicorn preload_app=true)
+#
+# If you're using preload_app=true in your Rainbows!/Unicorn
+# config file, just add the middleware to your stack:
+#
+# In your Rack config.ru:
+#
+#    use Raindrops::Middleware
+#
+# === Linux-only extras!
+#
+# To get bound listener statistics under \Linux, you need to specify the
+# listener names for your server.  You can even include listen sockets for
+# *other* servers on the same machine.  This can be handy for monitoring
+# your nginx proxy as well.
+#
+# In your Rack config.ru, just pass the :listeners argument as an array of
+# strings (along with any other arguments).  You can specify any
+# combination of TCP or Unix domain socket names:
+#
+#    use Raindrops::Middleware, :listeners => %w(0.0.0.0:80 /tmp/.sock)
+#
+# If you're running Unicorn 0.98.0 or later, you don't have to pass in
+# the :listeners array, Raindrops will automatically detect the listeners
+# used by Unicorn master process.  This does not detect listeners in
+# different processes, of course.
+#
+# The response body includes the following stats for each listener
+# (see also Raindrops::ListenStats):
+#
+# * active - total number of active clients on that listener
+# * queued - total number of queued (pre-accept()) clients on that listener
+#
+# = Demo Server
+#
+# There is a server running this middleware (and Watcher) at
+#  https://yhbt.net/raindrops-demo/_raindrops
+#
+# Also check out the Watcher demo at https://yhbt.net/raindrops-demo/
+#
+# The demo server is only limited to 30 users, so be sure not to abuse it
+# by using the /tail/ endpoint too much.
+#
+class Raindrops::Middleware
+  attr_accessor :app, :stats, :path, :tcp, :unix # :nodoc:
+
+  # A Raindrops::Struct used to count the number of :calling and :writing
+  # clients.  This struct is intended to be shared across multiple processes
+  # and both counters are updated atomically.
+  #
+  # This is supported on all operating systems supported by Raindrops
+  Stats = Raindrops::Struct.new(:calling, :writing)
+
+  # :stopdoc:
+  require "raindrops/middleware/proxy"
+  # :startdoc:
+
+  # +app+ may be any Rack application, this middleware wraps it.
+  # +opts+ is a hash that understands the following members:
+  #
+  # * :stats - Raindrops::Middleware::Stats struct (default: Stats.new)
+  # * :path - HTTP endpoint used for reading the stats (default: "/_raindrops")
+  # * :listeners - array of host:port or socket paths (default: from Unicorn)
+  def initialize(app, opts = {})
+    @app = app
+    @stats = opts[:stats] || Stats.new
+    @path = opts[:path] || "/_raindrops"
+    @mtx = Mutex.new
+    tmp = opts[:listeners]
+    if tmp.nil? && defined?(Unicorn) && Unicorn.respond_to?(:listener_names)
+      tmp = Unicorn.listener_names
+    end
+    @nl_sock = @tcp = @unix = nil
+
+    if tmp
+      @tcp = tmp.grep(/\A.+:\d+\z/)
+      @unix = tmp.grep(%r{\A/})
+      @tcp = nil if @tcp.empty?
+      @unix = nil if @unix.empty?
+    end
+  end
+
+  # standard Rack endpoint
+  def call(env) # :nodoc:
+    env['PATH_INFO'] == @path and return stats_response
+    begin
+      @stats.incr_calling
+
+      status, headers, body = @app.call(env)
+      rv = [ status, headers, Proxy.new(body, @stats) ]
+
+      # the Rack server will start writing headers soon after this method
+      @stats.incr_writing
+      rv
+    ensure
+      @stats.decr_calling
+    end
+  end
+
+  def stats_response  # :nodoc:
+    body = "calling: #{@stats.calling}\n" \
+           "writing: #{@stats.writing}\n"
+
+    if defined?(Raindrops::Linux.tcp_listener_stats)
+      @mtx.synchronize do
+        @nl_sock ||= Raindrops::InetDiagSocket.new
+        Raindrops::Linux.tcp_listener_stats(@tcp, @nl_sock).each do |addr,stats|
+          body << "#{addr} active: #{stats.active}\n" \
+                  "#{addr} queued: #{stats.queued}\n"
+        end
+      end if @tcp
+      Raindrops::Linux.unix_listener_stats(@unix).each do |addr,stats|
+        body << "#{addr} active: #{stats.active}\n" \
+                "#{addr} queued: #{stats.queued}\n"
+      end if @unix
+    end
+
+    headers = {
+      "Content-Type" => "text/plain",
+      "Content-Length" => body.size.to_s,
+    }
+    [ 200, headers, [ body ] ]
+  end
+end

data/lib/raindrops/struct.rb

@@ -0,0 +1,63 @@
+# -*- encoding: binary -*-
+# frozen_string_literal: false
+
+# This is a wrapper around Raindrops objects much like the core Ruby
+# \Struct can be seen as a wrapper around the core \Array class.
+# It's usage is similar to the core \Struct class, except its fields
+# may only be used to house unsigned long integers.
+#
+#   class Foo < Raindrops::Struct.new(:readers, :writers)
+#   end
+#
+#   foo = Foo.new 0, 0
+#
+#   foo.incr_writers    -> 1
+#   foo.incr_readers    -> 1
+#
+class Raindrops::Struct
+
+  # returns a new class derived from Raindrops::Struct and supporting
+  # the given +members+ as fields, just like \Struct.new in core Ruby.
+  def self.new(*members)
+    members = members.map { |x| x.to_sym }.freeze
+    str = <<EOS
+def initialize(*values)
+  (MEMBERS.size >= values.size) or raise ArgumentError, "too many arguments"
+  @raindrops = Raindrops.new(MEMBERS.size)
+  values.each_with_index { |val,i| @raindrops[i] = values[i] }
+end
+
+def initialize_copy(src)
+  @raindrops = src.instance_variable_get(:@raindrops).dup
+end
+
+def []=(index, value)
+  @raindrops[index] = value
+end
+
+def [](index)
+  @raindrops[index]
+end
+
+def to_hash
+  ary = @raindrops.to_ary
+  rv = {}
+  MEMBERS.each_with_index { |member, i| rv[member] = ary[i] }
+  rv
+end
+EOS
+
+    members.each_with_index do |member, i|
+      str << "def incr_#{member}; @raindrops.incr(#{i}); end; " \
+             "def decr_#{member}; @raindrops.decr(#{i}); end; " \
+             "def #{member}; @raindrops[#{i}]; end; " \
+             "def #{member}=(val); @raindrops[#{i}] = val; end; "
+    end
+
+    klass = Class.new
+    klass.const_set(:MEMBERS, members)
+    klass.class_eval(str)
+    klass
+  end
+
+end