raindrops 0.1.0

data/ext/raindrops/raindrops.c

@@ -0,0 +1,192 @@
+#include <ruby.h>
+#include <sys/mman.h>
+#include <assert.h>
+#include <errno.h>
+#include <stddef.h>
+
+/*
+ * most modern CPUs have a cache-line size of 64 or 128.
+ * We choose a bigger one by default since our structure is not
+ * heavily used
+ */
+#ifndef CACHE_LINE_SIZE
+#  define CACHE_LINE_SIZE 128
+#endif
+
+/* each raindrop is a counter */
+struct raindrop {
+	union {
+		unsigned long counter;
+		unsigned char padding[CACHE_LINE_SIZE];
+	} as;
+} __attribute__((packed));
+
+/* allow mmap-ed regions can store more than one raindrop */
+struct raindrops {
+	long size;
+	struct raindrop *drops;
+};
+
+/* called by GC */
+static void evaporate(void *ptr)
+{
+	struct raindrops *r = ptr;
+
+	if (r->drops) {
+		int rv = munmap(r->drops, sizeof(struct raindrop) * r->size);
+		if (rv != 0)
+			rb_bug("munmap failed in gc: %s", strerror(errno));
+	}
+
+	xfree(ptr);
+}
+
+/* automatically called at creation (before initialize) */
+static VALUE alloc(VALUE klass)
+{
+	struct raindrops *r;
+
+	return Data_Make_Struct(klass, struct raindrops, NULL, evaporate, r);
+}
+
+static struct raindrops *get(VALUE self)
+{
+	struct raindrops *r;
+
+	Data_Get_Struct(self, struct raindrops, r);
+
+	return r;
+}
+
+/* initializes a Raindrops object to hold +size+ elements */
+static VALUE init(VALUE self, VALUE size)
+{
+	struct raindrops *r = get(self);
+	int tries = 1;
+
+	if (r->drops)
+		rb_raise(rb_eRuntimeError, "already initialized");
+
+	r->size = NUM2LONG(size);
+	if (r->size < 1)
+		rb_raise(rb_eArgError, "size must be >= 1");
+
+retry:
+	r->drops = mmap(NULL, sizeof(struct raindrop) * r->size,
+	                PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
+	if (r->drops == MAP_FAILED) {
+		if ((errno == EAGAIN || errno == ENOMEM) && tries-- > 0) {
+			rb_gc();
+			goto retry;
+		}
+		rb_sys_fail("mmap");
+	}
+
+	return self;
+}
+
+/* :nodoc */
+static VALUE init_copy(VALUE dest, VALUE source)
+{
+	struct raindrops *dst = get(dest);
+	struct raindrops *src = get(source);
+
+	init(dest, LONG2NUM(src->size));
+	memcpy(dst->drops, src->drops, sizeof(struct raindrop) * src->size);
+
+	return dest;
+}
+
+static unsigned long *addr_of(VALUE self, VALUE index)
+{
+	struct raindrops *r = get(self);
+	unsigned long off = FIX2ULONG(index) * sizeof(struct raindrop);
+
+	if (off >= sizeof(struct raindrop) * r->size)
+		rb_raise(rb_eArgError, "offset overrun");
+
+	return (unsigned long *)((unsigned long)r->drops + off);
+}
+
+static unsigned long incr_decr_arg(int argc, const VALUE *argv)
+{
+	if (argc > 2 || argc < 1)
+		rb_raise(rb_eArgError,
+		         "wrong number of arguments (%d for 1+)", argc);
+
+	return argc == 2 ? NUM2ULONG(argv[1]) : 1;
+}
+
+/* increments the value referred to by the +index+ constant by 1 */
+static VALUE incr(int argc, VALUE *argv, VALUE self)
+{
+	unsigned long nr = incr_decr_arg(argc, argv);
+
+	return ULONG2NUM(__sync_add_and_fetch(addr_of(self, argv[0]), nr));
+}
+
+/* decrements the value referred to by the +index+ constant by 1 */
+static VALUE decr(int argc, VALUE *argv, VALUE self)
+{
+	unsigned long nr = incr_decr_arg(argc, argv);
+
+	return ULONG2NUM(__sync_sub_and_fetch(addr_of(self, argv[0]), nr));
+}
+
+/* converts the raindrops structure to an Array */
+static VALUE to_ary(VALUE self)
+{
+	struct raindrops *r = get(self);
+	VALUE rv = rb_ary_new2(r->size);
+	long i;
+	unsigned long base = (unsigned long)r->drops;
+
+	for (i = 0; i < r->size; i++) {
+		rb_ary_push(rv, ULONG2NUM(*((unsigned long *)base)));
+		base += sizeof(struct raindrop);
+	}
+
+	return rv;
+}
+
+static VALUE size(VALUE self)
+{
+	return LONG2NUM(get(self)->size);
+}
+
+static VALUE aset(VALUE self, VALUE index, VALUE value)
+{
+	unsigned long *addr = addr_of(self, index);
+
+	*addr = NUM2ULONG(value);
+
+	return value;
+}
+
+static VALUE aref(VALUE self, VALUE index)
+{
+	return  ULONG2NUM(*addr_of(self, index));
+}
+
+#ifdef __linux__
+void Init_raindrops_linux_inet_diag(void);
+#endif
+
+void Init_raindrops_ext(void)
+{
+	VALUE cRaindrops = rb_define_class("Raindrops", rb_cObject);
+	rb_define_alloc_func(cRaindrops, alloc);
+
+	rb_define_method(cRaindrops, "initialize", init, 1);
+	rb_define_method(cRaindrops, "incr", incr, -1);
+	rb_define_method(cRaindrops, "decr", decr, -1);
+	rb_define_method(cRaindrops, "to_ary", to_ary, 0);
+	rb_define_method(cRaindrops, "[]", aref, 1);
+	rb_define_method(cRaindrops, "[]=", aset, 2);
+	rb_define_method(cRaindrops, "size", size, 0);
+	rb_define_method(cRaindrops, "initialize_copy", init_copy, 1);
+
+#ifdef __linux__
+	Init_raindrops_linux_inet_diag();
+#endif
+}

data/lib/raindrops.rb

@@ -0,0 +1,35 @@
+# -*- encoding: binary -*-
+class Raindrops
+
+  # Raindrops is currently at version 0.1.0
+  VERSION = '0.1.0'
+
+  # Used to represent the number of +active+ and +queued+ sockets for
+  # a single listen socket across all threads and processes on a
+  # machine.
+  #
+  # For TCP listeners, only sockets in the TCP_ESTABLISHED state are
+  # accounted for.  For Unix domain listeners, only CONNECTING and
+  # CONNECTED Unix domain sockets are accounted for.
+  #
+  # +active+ connections is the number of accept()-ed but not-yet-closed
+  # sockets in all threads/processes sharing the given listener.
+  #
+  # +queued+ connections is the number of un-accept()-ed sockets in the
+  # queue of a given listen socket.
+  #
+  # These stats are currently only available under Linux
+  class ListenStats < Struct.new(:active, :queued)
+
+    # the sum of +active+ and +queued+ sockets
+    def total
+      active + queued
+    end
+  end
+
+  # TODO: pure Ruby version for single processes
+  require 'raindrops_ext'
+
+  autoload :Struct, 'raindrops/struct'
+  autoload :Middleware, 'raindrops/middleware'
+end

data/lib/raindrops/linux.rb

@@ -0,0 +1,55 @@
+# -*- encoding: binary -*-
+class Raindrops
+module 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 = "/proc/net/unix"
+
+  # 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#active
+  # * SS_CONNECTED maps to ListenStats#queued
+  #
+  # 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)
+    rv = Hash.new { |h,k| h[k.freeze] = ListenStats.new(0, 0) }
+    paths = paths.map do |path|
+      path = path.dup
+      path.force_encoding(Encoding::BINARY) if defined?(Encoding)
+      rv[path]
+      Regexp.escape(path)
+    end
+    paths = / 00000000 \d+ (\d+)\s+\d+ (#{paths.join('|')})$/n
+
+    # no point in pread since we can't stat for size on this file
+    File.open(PROC_NET_UNIX, "rb") do |fp|
+      fp.read.scan(paths).each do |s|
+        path = s.last
+        case s.first.to_i
+        when 2 then rv[path].queued += 1
+        when 3 then rv[path].active += 1
+        end
+      end
+    end
+
+    rv
+  end
+
+  module_function :unix_listener_stats
+
+end # Linux
+end # Raindrops

data/lib/raindrops/middleware.rb

@@ -0,0 +1,75 @@
+# -*- encoding: binary -*-
+require 'raindrops'
+
+# Raindrops middleware should be loaded at the top of Rack
+# middleware stack before other middlewares for maximum accuracy.
+class Raindrops
+class Middleware < ::Struct.new(:app, :stats, :path, :tcp, :unix)
+
+  # :stopdoc:
+  Stats = Raindrops::Struct.new(:calling, :writing)
+  PATH_INFO = "PATH_INFO"
+  # :startdoc:
+
+  def initialize(app, opts = {})
+    super(app, opts[:stats] || Stats.new, opts[:path] || "/_raindrops")
+    if tmp = opts[:listeners]
+      self.tcp = tmp.grep(/\A[^:]+:\d+\z/)
+      self.unix = tmp.grep(%r{\A/})
+      self.tcp = nil if tcp.empty?
+      self.unix = nil if unix.empty?
+    end
+  end
+
+  # standard Rack endpoing
+  def call(env)
+    env[PATH_INFO] == path ? stats_response : dup._call(env)
+  end
+
+  def _call(env)
+    stats.incr_calling
+    status, headers, self.app = app.call(env)
+
+    # the Rack server will start writing headers soon after this method
+    stats.incr_writing
+    [ status, headers, self ]
+    ensure
+      stats.decr_calling
+  end
+
+  # yield to the Rack server here for writing
+  def each(&block)
+    app.each(&block)
+  end
+
+  # the Rack server should call this after #each (usually ensure-d)
+  def close
+    stats.decr_writing
+    ensure
+      app.close if app.respond_to?(:close)
+  end
+
+  def stats_response
+    body = "calling: #{stats.calling}\n" \
+           "writing: #{stats.writing}\n"
+
+    if defined?(Linux)
+      Linux.tcp_listener_stats(tcp).each do |addr,stats|
+        body << "#{addr} active: #{stats.active}\n" \
+                "#{addr} queued: #{stats.queued}\n"
+      end if tcp
+      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
+end

data/lib/raindrops/struct.rb

@@ -0,0 +1,47 @@
+# -*- encoding: binary -*-
+
+class Raindrops::Struct
+
+  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

data/raindrops.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: binary -*-
+
+ENV["VERSION"] or abort "VERSION= must be specified"
+manifest = File.readlines('.manifest').map! { |x| x.chomp! }
+test_files = manifest.grep(%r{\Atest/test_.*\.rb\z})
+
+Gem::Specification.new do |s|
+  s.name = %q{raindrops}
+  s.version = ENV["VERSION"]
+
+  s.authors = ["raindrops hackers"]
+  s.date = Time.now.utc.strftime('%Y-%m-%d')
+  s.description = File.read("README").split(/\n\n/)[1]
+  s.email = %q{raindrops@librelist.com}
+  s.extensions = %w(ext/raindrops/extconf.rb)
+
+  s.extra_rdoc_files = File.readlines('.document').map! do |x|
+    x.chomp!
+    if File.directory?(x)
+      manifest.grep(%r{\A#{x}/})
+    elsif File.file?(x)
+      x
+    else
+      nil
+    end
+  end.flatten.compact
+
+  s.files = manifest
+  s.homepage = %q{http://raindrops.bogomips.org/}
+  s.summary = %q{real-time stats for Rack servers}
+  s.rdoc_options = [ "-Na", "-t", "raindrops - #{s.summary}" ]
+  s.require_paths = %w(lib)
+  s.rubyforge_project = %q{raindrops}
+
+  s.test_files = test_files
+
+  # s.licenses = %w(LGPLv3) # accessor not compatible with older RubyGems
+end