raindrops 0.13.0 → 0.19.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1e1444bc6e35e67993745b3627e848537490fd3b02a67e12be9721b031e22e70
+  data.tar.gz: 9ed2dff40418e89a71ecf18cfb74b72d28d9570ceef314ee1c81bdff19ed832a
+SHA512:
+  metadata.gz: ccb15ce6a96c1619d53d6090851ef8152ebd673b2db8aed9c6d4bb42757de2d9d051888d3f105d6d3461683eb33575d343e7d31a1ddb91a8f9914bb4e6abcb81
+  data.tar.gz: ce265e39bf3217f3b62931ead0fff78e7e118785466bc0eecff1858f9d808982c12b14f2645ecfffd96c8cb8e0a1a72ac03c0d6ad220c84950dfd2fe05d7f258

data/.document

@@ -1,8 +1,7 @@
 README
 LICENSE
 NEWS
-ChangeLog
 lib
 ext/raindrops/raindrops.c
 ext/raindrops/linux_inet_diag.c
-ext/raindrops/linux_tcp_info.c
+ext/raindrops/tcp_info.c

data/.gitattributes

@@ -0,0 +1,4 @@
+*.gemspec diff=ruby
+*.rb diff=ruby
+*.ru diff=ruby
+Rakefile diff=ruby

data/.gitignore

@@ -5,7 +5,7 @@
 Makefile
 /GIT-VERSION-FILE
 /local.mk
-/NEWS
+/NEWS*
 /ChangeLog
 /.manifest
 /man

data/.olddoc.yml

@@ -0,0 +1,13 @@
+---
+cgit_url: https://yhbt.net/raindrops.git/
+rdoc_url: https://yhbt.net/raindrops/
+public_email: raindrops-public@yhbt.net
+ml_url:
+- https://yhbt.net/raindrops-public/
+- http://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/raindrops-public
+nntp_url:
+- nntp://news.public-inbox.org/inbox.comp.lang.ruby.raindrops
+- nntp://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/inbox.comp.lang.ruby.raindrops
+source_code:
+- git clone https://yhbt.net/raindrops.git
+- torsocks git clone http://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/raindrops.git

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v0.13.0
+DEF_VER=v0.19.2
 
 LF='
 '

data/GNUmakefile

@@ -1,5 +1,4 @@
 all::
-RSYNC_DEST := bogomips.org:/srv/raindrops
-rfproject := rainbows
+RSYNC_DEST := yhbt.net:/srv/yhbt/raindrops
 rfpackage := raindrops
 include pkg.mk

data/LICENSE

@@ -3,8 +3,8 @@ revision control for names and email addresses of all of them.
 
 You can redistribute it and/or modify it under the terms of the GNU
 Lesser General Public License (LGPL) as published by the Free Software
-Foundation, version {2.1}[http://www.gnu.org/licenses/lgpl-2.1.txt] or
-later.  Currently version {3}[http://www.gnu.org/licenses/lgpl-3.0.txt],
+Foundation, version {2.1}[https://www.gnu.org/licenses/lgpl-2.1.txt] or
+later.  Currently version {3}[https://www.gnu.org/licenses/lgpl-3.0.txt],
 is preferred (see link:COPYING).
 
 raindrops is distributed in the hope that it will be useful, but WITHOUT
@@ -13,4 +13,4 @@ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 License for more details.
 
 You should have received a copy of the GNU Lesser General Public License
-along with the raindrops; if not, see <http://www.gnu.org/licenses/>
+along with the raindrops; if not, see <https://www.gnu.org/licenses/>

data/README

@@ -1,11 +1,10 @@
 = raindrops - real-time stats for preforking Rack servers
 
-Raindrops is a real-time stats toolkit to show statistics for Rack HTTP
-servers.  It is designed for preforking servers such as Rainbows! and
-Unicorn, but should support any Rack HTTP server under Ruby 2.0, 1.9,
-1.8 and Rubinius on platforms supporting POSIX shared memory.  It may
-also be used as a generic scoreboard for sharing atomic counters across
-multiple processes.
+raindrops is a real-time stats toolkit to show statistics for Rack HTTP
+servers.  It is designed for preforking servers such as unicorn, but
+should support any Rack HTTP server on platforms supporting POSIX shared
+memory.  It may also be used as a generic scoreboard for sharing atomic
+counters across multiple processes.
 
 == Features
 
@@ -38,12 +37,15 @@ and "tcp_diag" kernel modules are loaded as they do not autoload correctly
 
 == Install
 
-We recommend GCC 4+ (or compatible) to support the
-{atomic builtins}[http://gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html]
-(__sync_{add,sub}_and_fetch()).  For non-GCC 4+ users, we also support
-compilation with the
-{libatomic_ops}[http://www.hpl.hp.com/research/linux/atomic_ops/]
-package starting with Raindrops 0.4.0.
+We recommend GCC 4+ (or compatible) to support the __sync builtins
+(__sync_{add,sub}_and_fetch()):
+
+https://gcc.gnu.org/onlinedocs/gcc/_005f_005fsync-Builtins.html
+
+For non-GCC 4+ users, we also support compilation with the libatomic_ops
+package starting with Raindrops 0.4.0:
+
+https://github.com/ivmai/libatomic_ops
 
 If you're using a packaged Ruby distribution, make sure you have a C
 compiler and the matching Ruby development libraries and headers.
@@ -52,30 +54,25 @@ If you use RubyGems:
 
     gem install raindrops
 
-Otherwise grab the latest tarball from:
-
-http://raindrops.bogomips.org/files/
-
-Unpack it, and run "ruby setup.rb"
-
 == Usage
 
 See Raindrops::Middleware and Raindrops::LastDataRecv documentation for
 use Rack servers.  The entire library is fully-documented and we are
-responsive on the mailing list (mailto:raindrops@librelist.org) if you
-have any questions or comments.
+responsive on the publically archived mailing list
+(mailto:raindrops-public@yhbt.net) if
+you have any questions or comments.
 
 == Development
 
 You can get the latest source via git from the following locations:
 
-  git://bogomips.org/raindrops.git
+  git://yhbt.net/raindrops.git
   git://repo.or.cz/raindrops.git (mirror)
 
 You may browse the code from the web and download the latest snapshot
 tarballs here:
 
-* http://bogomips.org/raindrops.git (cgit)
+* https://yhbt.net/raindrops.git
 * http://repo.or.cz/w/raindrops.git (gitweb)
 
 Inline patches (from "git format-patch") to the mailing list are
@@ -87,22 +84,19 @@ git itself.  See the Documentation/SubmittingPatches document
 distributed with git on on patch submission guidelines to follow.  Just
 don't email the git mailing list or maintainer with raindrops patches.
 
-raindrops is currently dual-licensed under the LGPLv2.1 and LGPLv3.  To
-allow for a transition to future versions of the LGPL, contributors are
-required to sign-off changes allowing allowing the project leader to
-relicense raindrops under newer versions of the LGPL (which should be
-similar in spirit to the existing LGPL).
+raindrops is licensed under the LGPL-2.1+
 
 == Contact
 
 All feedback (bug reports, user/development discussion, patches, pull
-requests) go to the mailing list: mailto:raindrops@librelist.org
-
-The mailing list is mirrored to Gmane, all information about the
-group is here:
+requests) go to the publically archived mailing list:
+mailto:raindrops-public@yhbt.net
 
-http://gmane.org/info.php?group=gmane.comp.lang.ruby.raindrops.general
+Mailing list archives are available over HTTPS and NNTP:
 
-Mailing list archives in mbox format may be downloaded here:
+* https://yhbt.net/raindrops-public/
+* http://7fh6tueqddpjyxjmgtdiueylzoqt6pt7hec3pukyptlmohoowvhde4yd.onion/raindrops-public/
+* nntp://news.public-inbox.org/inbox.comp.lang.ruby.raindrops
 
-http://raindrops.bogomips.org/archives/
+Since archives are public, scrub sensitive information and
+use anonymity tools such as Tor or Mixmaster if you deem necessary.

data/TODO

@@ -1 +1,3 @@
+* fix IPv6 inet_diag reporting for Raindrops::Middleware
 * pure Ruby version for non-forking servers (patches welcome!)
+* unix_diag and udp_diag support

data/archive/.gitignore

@@ -0,0 +1,3 @@
+/data
+/news
+/requests

data/archive/slrnpull.conf

@@ -0,0 +1,4 @@
+# group_name                         max        expire     headers_only
+gmane.comp.lang.ruby.raindrops.general 1000000000 1000000000 0
+
+# usage: slrnpull -d $PWD -h news.gmane.org --no-post

data/examples/linux-listener-stats.rb

@@ -15,7 +15,6 @@
 usage = "Usage: #$0 [-d DELAY] [-t QUEUED_THRESHOLD] ADDR..."
 ARGV.size > 0 or abort usage
 delay = false
-all = false
 queued_thresh = -1
 # "normal" exits when driven on the command-line
 trap(:INT) { exit 130 }
@@ -25,7 +24,7 @@
   opts.banner = usage
   opts.on('-d', '--delay=DELAY', Float) { |n| delay = n }
   opts.on('-t', '--queued-threshold=INT', Integer) { |n| queued_thresh = n }
-  opts.on('-a', '--all') { all = true }
+  opts.on('-a', '--all') { } # noop
   opts.parse! ARGV
 end
 

data/examples/watcher_demo.ru

@@ -1,5 +1,5 @@
 # This is a snippet of the config that powers
-# http://raindrops-demo.bogomips.org/
+# https://yhbt.net/raindrops-demo/
 # This may be used with the packaged zbatery.conf.rb
 #
 # zbatery -c zbatery.conf.ru watcher_demo.ru -E none

data/examples/yahns.conf.rb

@@ -0,0 +1,30 @@
+# Inlined rack app using yahns server (git clone git://yhbt.net/yahns.git)
+# Usage: yahns -c /path/to/this/file.conf.rb
+# There is no separate config.ru file for this example,
+# but rack_app may also be a string pointing to the path of a
+# config.ru file
+
+require 'rack'
+rack_app = Rack::Builder.new do
+  use Rack::Head
+  addr = %w(0.0.0.0:9418 0.0.0.0:443 [::]:443 0.0.0.0:80 [::]:80
+	    127.0.0.1:6081 127.0.0.1:280 0.0.0.0:119 [::]:119)
+  use Raindrops::Middleware, listeners: addr
+  run Raindrops::Watcher.new(listeners: addr)
+end.to_app
+# rack_app = '/path/to/config.ru' # a more standard config
+
+app(:rack, rack_app) do
+  # I keep IPv4 and IPv6 on separate sockets to avoid ugly
+  # IPv4-mapped-IPv6 addresses:
+  listen 8080
+  listen '[::]:8080', ipv6only: true
+  client_max_body_size 0 # no POST or any uploads
+  client_timeout 5
+  output_buffering false # needed for /tail/ endpoint to avoid ENOSPC
+  queue { worker_threads 30 }
+end
+
+# logging is optional, but recommended for diagnosing problems
+# stderr_path '/var/log/yahns/stderr-raindrops.log'
+# stdout_path '/var/log/yahns/stdout-raindrops.log'

data/examples/zbatery.conf.rb

@@ -1,6 +1,9 @@
 # Used for running Raindrops::Watcher, which requires a multi-threaded
 # Rack server capable of streaming a response.  Threads must be used,
-# so Zbatery is recommended: http://zbatery.bogomip.org/
+# so any multi-threaded Rack server may be used.
+# zbatery was recommended in the past, but it is abandoned
+# <http://zbatery.bogomip.org/>.
+# yahns may work as an alternative (see yahns.conf.rb in this dir)
 Rainbows! do
   use :ThreadSpawn
 end

data/ext/raindrops/extconf.rb

@@ -1,4 +1,5 @@
 require 'mkmf'
+require 'shellwords'
 
 dir_config('atomic_ops')
 have_func('mmap', 'sys/mman.h') or abort 'mmap() not found'
@@ -6,9 +7,112 @@
 
 $CPPFLAGS += " -D_GNU_SOURCE "
 have_func('mremap', 'sys/mman.h')
+headers = %w(sys/types.h netdb.h string.h sys/socket.h netinet/in.h)
+if have_header('linux/tcp.h')
+  headers << 'linux/tcp.h'
+else
+  %w(netinet/tcp.h netinet/tcp_fsm.h).each { |h|
+    have_header(h, headers) and headers << h
+  }
+end
 
 $CPPFLAGS += " -D_BSD_SOURCE "
+
+if have_type("struct tcp_info", headers)
+  %w(
+    tcpi_state
+    tcpi_ca_state
+    tcpi_retransmits
+    tcpi_probes
+    tcpi_backoff
+    tcpi_options
+    tcpi_snd_wscale
+    tcpi_rcv_wscale
+    tcpi_rto
+    tcpi_ato
+    tcpi_snd_mss
+    tcpi_rcv_mss
+    tcpi_unacked
+    tcpi_sacked
+    tcpi_lost
+    tcpi_retrans
+    tcpi_fackets
+    tcpi_last_data_sent
+    tcpi_last_ack_sent
+    tcpi_last_data_recv
+    tcpi_last_ack_recv
+    tcpi_pmtu
+    tcpi_rcv_ssthresh
+    tcpi_rtt
+    tcpi_rttvar
+    tcpi_snd_ssthresh
+    tcpi_snd_cwnd
+    tcpi_advmss
+    tcpi_reordering
+    tcpi_rcv_rtt
+    tcpi_rcv_space
+    tcpi_total_retrans
+    tcpi_snd_wnd
+    tcpi_snd_bwnd
+    tcpi_snd_nxt
+    tcpi_rcv_nxt
+    tcpi_toe_tid
+    tcpi_snd_rexmitpack
+    tcpi_rcv_ooopack
+    tcpi_snd_zerowin
+  ).each do |field|
+    cfunc = "tcp_info_#{field}"
+    if have_struct_member('struct tcp_info', field, headers)
+      func_body = <<EOF
+static VALUE #{cfunc}(VALUE self)
+{
+	struct tcp_info *info = DATA_PTR(self);
+	return UINT2NUM((uint32_t)info->#{field});
+}
+EOF
+      func_body.delete!("\n")
+      $defs << "-DCFUNC_#{cfunc}=#{Shellwords.shellescape(func_body)}"
+    else
+      func_body = "static inline void #{cfunc}(void) {}"
+      $defs << "-DCFUNC_#{cfunc}=#{Shellwords.shellescape(func_body)}"
+      cfunc = 'rb_f_notimplement'.freeze
+    end
+    rbmethod = %Q("#{field.sub(/\Atcpi_/, ''.freeze)}")
+    $defs << "-DDEFINE_METHOD_tcp_info_#{field}=" \
+	     "#{Shellwords.shellescape(
+                %Q[rb_define_method(cTCP_Info,#{rbmethod},#{cfunc},0)])}"
+  end
+  tcp_state_map = {
+    ESTABLISHED: %w(TCP_ESTABLISHED TCPS_ESTABLISHED),
+    SYN_SENT: %w(TCP_SYN_SENT TCPS_SYN_SENT),
+    SYN_RECV: %w(TCP_SYN_RECV TCPS_SYN_RECEIVED),
+    FIN_WAIT1: %w(TCP_FIN_WAIT1 TCPS_FIN_WAIT_1),
+    FIN_WAIT2: %w(TCP_FIN_WAIT2 TCPS_FIN_WAIT_2),
+    TIME_WAIT: %w(TCP_TIME_WAIT TCPS_TIME_WAIT),
+    CLOSE: %w(TCP_CLOSE TCPS_CLOSED),
+    CLOSE_WAIT: %w(TCP_CLOSE_WAIT TCPS_CLOSE_WAIT),
+    LAST_ACK: %w(TCP_LAST_ACK TCPS_LAST_ACK),
+    LISTEN: %w(TCP_LISTEN TCPS_LISTEN),
+    CLOSING: %w(TCP_CLOSING TCPS_CLOSING),
+  }
+  nstate = 0
+  tcp_state_map.each do |state, try|
+    try.each do |os_name|
+      have_const(os_name, headers) or next
+      tcp_state_map[state] = os_name
+      nstate += 1
+    end
+  end
+  if nstate == tcp_state_map.size
+    $defs << '-DRAINDROPS_TCP_STATES_ALL_KNOWN=1'
+    tcp_state_map.each do |state, name|
+      $defs << "-DRAINDROPS_TCP_#{state}=#{name}"
+    end
+  end
+end
+
 have_func("getpagesize", "unistd.h")
+have_func('rb_thread_call_without_gvl')
 have_func('rb_thread_blocking_region')
 have_func('rb_thread_io_blocking_region')
 
@@ -39,17 +143,18 @@
       $defs.push(format("-DHAVE_GCC_ATOMIC_BUILTINS"))
       true
     else
-      prev_cflags = $CFLAGS
+      $CFLAGS = prev_cflags
       false
     end
   end
 end or have_header('atomic_ops.h') or abort <<-SRC
 
 libatomic_ops is required if GCC 4+ is not used.
-See http://www.hpl.hp.com/research/linux/atomic_ops/
+See https://github.com/ivmai/libatomic_ops
 
 Users of Debian-based distros may run:
 
   apt-get install libatomic-ops-dev
 SRC
+create_header # generate extconf.h to avoid excessively long command-line
 create_makefile('raindrops_ext')

data/ext/raindrops/linux_inet_diag.c

@@ -1,45 +1,24 @@
 #include <ruby.h>
-#ifdef HAVE_RUBY_ST_H
-#  include <ruby/st.h>
-#else
-#  include <st.h>
-#endif
+#include <stdarg.h>
+#include <ruby/st.h>
 #include "my_fileno.h"
 #ifdef __linux__
 
-/* Ruby 1.8.6+ macros (for compatibility with Ruby 1.9) */
-#ifndef RSTRING_LEN
-#  define RSTRING_LEN(s) (RSTRING(s)->len)
-#endif
-
-/* partial emulation of the 1.9 rb_thread_blocking_region under 1.8 */
-#if !defined(HAVE_RB_THREAD_BLOCKING_REGION) && \
-    !defined(HAVE_RB_THREAD_IO_BLOCKING_REGION)
-#  include <rubysig.h>
-#  define RUBY_UBF_IO ((rb_unblock_function_t *)-1)
-typedef void rb_unblock_function_t(void *);
-typedef VALUE rb_blocking_function_t(void *);
-static VALUE
-rb_thread_blocking_region(
-	rb_blocking_function_t *func, void *data1,
-	rb_unblock_function_t *ubf, void *data2)
-{
-	VALUE rv;
-
-	TRAP_BEG;
-	rv = func(data1);
-	TRAP_END;
-
-	return rv;
-}
-#endif /* ! HAVE_RB_THREAD_BLOCKING_REGION */
-
 #ifdef HAVE_RB_THREAD_IO_BLOCKING_REGION
+/* Ruby 1.9.3 and 2.0.0 */
 VALUE rb_thread_io_blocking_region(rb_blocking_function_t *, void *, int);
+#  define rd_fd_region(fn,data,fd) \
+	rb_thread_io_blocking_region((fn),(data),(fd))
+#elif defined(HAVE_RB_THREAD_CALL_WITHOUT_GVL) && \
+	defined(HAVE_RUBY_THREAD_H) && HAVE_RUBY_THREAD_H
+/* in case Ruby 2.0+ ever drops rb_thread_io_blocking_region: */
+#  include <ruby/thread.h>
+#  define COMPAT_FN (void *(*)(void *))
+#  define rd_fd_region(fn,data,fd) \
+	rb_thread_call_without_gvl(COMPAT_FN(fn),(data),RUBY_UBF_IO,NULL)
 #else
-#  define rb_thread_io_blocking_region(fn,data,fd) \
-      rb_thread_blocking_region((fn),(data),RUBY_UBF_IO,0)
-#endif /* HAVE_RB_THREAD_IO_BLOCKING_REGION */
+#  error Ruby <= 1.8 not supported
+#endif
 
 #include <assert.h>
 #include <errno.h>
@@ -213,91 +192,89 @@ static const char *addr_any(sa_family_t family)
 	return ipv6;
 }
 
-static void bug_warn(void)
+#ifdef __GNUC__
+static void bug_warn_nogvl(const char *, ...)
+	__attribute__((format(printf,1,2)));
+#endif
+static void bug_warn_nogvl(const char *fmt, ...)
 {
+	va_list ap;
+
+	va_start(ap, fmt);
+	vfprintf(stderr, fmt, ap);
+	va_end(ap);
+
 	fprintf(stderr, "Please report how you produced this at "\
-	                "raindrops@librelist.org\n");
+	                "raindrops-public@yhbt.net\n");
 	fflush(stderr);
 }
 
 static struct listen_stats *stats_for(st_table *table, struct inet_diag_msg *r)
 {
-	char *key, *port, *old_key;
+	char *host, *key, *port, *old_key;
 	size_t alloca_len;
 	struct listen_stats *stats;
-	size_t keylen;
-	size_t portlen = sizeof("65535");
-	union any_addr sa;
-	socklen_t len = sizeof(struct sockaddr_storage);
-	int rc;
-	int flags = NI_NUMERICHOST | NI_NUMERICSERV;
-
-	switch ((sa.ss.ss_family = r->idiag_family)) {
+	socklen_t hostlen;
+	socklen_t portlen = (socklen_t)sizeof("65535");
+	int n;
+	const void *src = r->id.idiag_src;
+
+	switch (r->idiag_family) {
 	case AF_INET: {
-		sa.in.sin_port = r->id.idiag_sport;
-		sa.in.sin_addr.s_addr = r->id.idiag_src[0];
-		keylen = INET_ADDRSTRLEN;
-		alloca_len = keylen + 1 + portlen;
-		key = alloca(alloca_len);
-		key[keylen] = 0; /* will be ':' later */
-		port = key + keylen + 1;
-		rc = getnameinfo(&sa.sa, len,
-				 key, keylen, port, portlen, flags);
+		hostlen = INET_ADDRSTRLEN;
+		alloca_len = hostlen + portlen;
+		host = key = alloca(alloca_len);
 		break;
 		}
 	case AF_INET6: {
-		sa.in6.sin6_port = r->id.idiag_sport;
-		memcpy(&sa.in6.sin6_addr, &r->id.idiag_src, sizeof(__be32[4]));
-		keylen = INET6_ADDRSTRLEN;
-		          /* [            ] */
-		alloca_len = 1 + keylen + 1 + 1 + portlen;
+		hostlen = INET6_ADDRSTRLEN;
+		alloca_len = 1 + hostlen + 1 + portlen;
 		key = alloca(alloca_len);
-		*key = '[';
-		key[1 + keylen + 1] = 0; /* will be ':' later */
-		port = 1 + key + keylen + 1 + 1;
-		rc = getnameinfo(&sa.sa, len,
-				 key + 1, keylen, port, portlen, flags);
+		host = key + 1;
 		break;
 		}
 	default:
 		assert(0 && "unsupported address family, could that be IPv7?!");
 	}
-	if (rc != 0) {
-		fprintf(stderr, "BUG: getnameinfo: %s\n", gai_strerror(rc));
-		bug_warn();
-		*key = 0;
+	if (!inet_ntop(r->idiag_family, src, host, hostlen)) {
+		bug_warn_nogvl("BUG: inet_ntop: %s\n", strerror(errno));
+		*key = '\0';
+		*host = '\0';
 	}
-
-	keylen = strlen(key);
-	portlen = strlen(port);
-
-	switch (sa.ss.ss_family) {
+	hostlen = (socklen_t)strlen(host);
+	switch (r->idiag_family) {
 	case AF_INET:
-		key[keylen] = ':';
-		memmove(key + keylen + 1, port, portlen + 1);
+		host[hostlen] = ':';
+		port = host + hostlen + 1;
 		break;
 	case AF_INET6:
-		key[keylen] = ']';
-		key[keylen + 1] = ':';
-		memmove(key + keylen + 2, port, portlen + 1);
-		keylen++;
+		key[0] = '[';
+		host[hostlen] = ']';
+		host[hostlen + 1] = ':';
+		port = host + hostlen + 2;
 		break;
 	default:
 		assert(0 && "unsupported address family, could that be IPv7?!");
 	}
 
+	n = snprintf(port, portlen, "%u", ntohs(r->id.idiag_sport));
+	if (n <= 0) {
+		bug_warn_nogvl("BUG: snprintf port: %d\n", n);
+		*key = '\0';
+	}
+
 	if (st_lookup(table, (st_data_t)key, (st_data_t *)&stats))
 		return stats;
 
 	old_key = key;
 
 	if (r->idiag_state == TCP_ESTABLISHED) {
-		int n = snprintf(key, alloca_len, "%s:%u",
-				 addr_any(sa.ss.ss_family),
+		n = snprintf(key, alloca_len, "%s:%u",
+				 addr_any(r->idiag_family),
 				 ntohs(r->id.idiag_sport));
 		if (n <= 0) {
-			fprintf(stderr, "BUG: snprintf: %d\n", n);
-			bug_warn();
+			bug_warn_nogvl("BUG: snprintf: %d\n", n);
+			*key = '\0';
 		}
 		if (st_lookup(table, (st_data_t)key, (st_data_t *)&stats))
 			return stats;
@@ -310,8 +287,9 @@ static struct listen_stats *stats_for(st_table *table, struct inet_diag_msg *r)
 			memcpy(key, old_key, n + 1);
 		}
 	} else {
-		key = xmalloc(keylen + 1 + portlen + 1);
-		memcpy(key, old_key, keylen + 1 + portlen + 1);
+		size_t old_len = strlen(old_key) + 1;
+		key = xmalloc(old_len);
+		memcpy(key, old_key, old_len);
 	}
 	stats = xcalloc(1, sizeof(struct listen_stats));
 	st_insert(table, (st_data_t)key, (st_data_t)stats);
@@ -391,8 +369,8 @@ static void prep_diag_args(
 
 	nladdr->nl_family = AF_NETLINK;
 
-	req->nlh.nlmsg_len = sizeof(struct diag_req) +
-	                    RTA_LENGTH(args->iov[2].iov_len);
+	req->nlh.nlmsg_len = (unsigned int)(sizeof(struct diag_req) +
+	                    RTA_LENGTH(args->iov[2].iov_len));
 	req->nlh.nlmsg_type = TCPDIAG_GETSOCK;
 	req->nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
 	req->nlh.nlmsg_pid = getpid();
@@ -465,12 +443,12 @@ static VALUE diag(void *ptr)
 		}
 	}
 out:
-	{
+	/* prepare to raise, free memory before reacquiring GVL */
+	if (err && args->table) {
 		int save_errno = errno;
-		if (err && args->table) {
-			st_foreach(args->table, st_free_data, 0);
-			st_free_table(args->table);
-		}
+
+		st_foreach(args->table, st_free_data, 0);
+		st_free_table(args->table);
 		errno = save_errno;
 	}
 	return (VALUE)err;
@@ -584,6 +562,10 @@ static void gen_bytecode(struct iovec *iov, union any_addr *inet)
 	}
 }
 
+/*
+ * n.b. we may safely raise here because an error will cause diag()
+ * to free args->table
+ */
 static void nl_errcheck(VALUE r)
 {
 	const char *err = (const char *)r;
@@ -604,11 +586,18 @@ static VALUE tcp_stats(struct nogvl_args *args, VALUE addr)
 	gen_bytecode(&args->iov[2], &query_addr);
 
 	memset(&args->stats, 0, sizeof(struct listen_stats));
-	nl_errcheck(rb_thread_io_blocking_region(diag, args, args->fd));
+	nl_errcheck(rd_fd_region(diag, args, args->fd));
 
 	return rb_listen_stats(&args->stats);
 }
 
+static int drop_placeholders(st_data_t k, st_data_t v, st_data_t ign)
+{
+	if ((VALUE)v == Qtrue)
+		return ST_DELETE;
+	return ST_CONTINUE;
+}
+
 /*
  * call-seq:
  *      Raindrops::Linux.tcp_listener_stats([addrs[, sock]]) => hash
@@ -649,10 +638,9 @@ static VALUE tcp_listener_stats(int argc, VALUE *argv, VALUE self)
 	case T_ARRAY: {
 		long i;
 		long len = RARRAY_LEN(addrs);
-		VALUE cur;
 
 		if (len == 1) {
-			cur = rb_ary_entry(addrs, 0);
+			VALUE cur = rb_ary_entry(addrs, 0);
 
 			rb_hash_aset(rv, cur, tcp_stats(&args, cur));
 			return rv;
@@ -662,7 +650,7 @@ static VALUE tcp_listener_stats(int argc, VALUE *argv, VALUE self)
 			VALUE cur = rb_ary_entry(addrs, i);
 
 			parse_addr(&check, cur);
-			rb_hash_aset(rv, cur, Qtrue);
+			rb_hash_aset(rv, cur, Qtrue /* placeholder */);
 		}
 		/* fall through */
 	}
@@ -675,11 +663,14 @@ static VALUE tcp_listener_stats(int argc, VALUE *argv, VALUE self)
 		         "addr must be an array of strings, a string, or nil");
 	}
 
-	nl_errcheck(rb_thread_io_blocking_region(diag, &args, args.fd));
+	nl_errcheck(rd_fd_region(diag, &args, args.fd));
 
 	st_foreach(args.table, NIL_P(addrs) ? st_to_hash : st_AND_hash, rv);
 	st_free_table(args.table);
 
+	if (RHASH_SIZE(rv) > 1)
+		rb_hash_foreach(rv, drop_placeholders, Qfalse);
+
 	/* let GC deal with corner cases */
 	if (argc < 2) rb_io_close(sock);
 	return rv;
@@ -687,11 +678,12 @@ static VALUE tcp_listener_stats(int argc, VALUE *argv, VALUE self)
 
 void Init_raindrops_linux_inet_diag(void)
 {
-	VALUE cRaindrops = rb_const_get(rb_cObject, rb_intern("Raindrops"));
+	VALUE cRaindrops = rb_define_class("Raindrops", rb_cObject);
 	VALUE mLinux = rb_define_module_under(cRaindrops, "Linux");
+	VALUE Socket;
 
 	rb_require("socket");
-	cIDSock = rb_const_get(rb_cObject, rb_intern("Socket"));
+	Socket = rb_const_get(rb_cObject, rb_intern("Socket"));
 	id_new = rb_intern("new");
 
 	/*
@@ -700,10 +692,11 @@ void Init_raindrops_linux_inet_diag(void)
 	 * This is a subclass of +Socket+ specifically for talking
 	 * to the inet_diag facility of Netlink.
 	 */
-	cIDSock = rb_define_class_under(cRaindrops, "InetDiagSocket", cIDSock);
+	cIDSock = rb_define_class_under(cRaindrops, "InetDiagSocket", Socket);
 	rb_define_singleton_method(cIDSock, "new", ids_s_new, 0);
 
 	cListenStats = rb_const_get(cRaindrops, rb_intern("ListenStats"));
+	rb_gc_register_mark_object(cListenStats); /* pin */
 
 	rb_define_module_function(mLinux, "tcp_listener_stats",
 	                          tcp_listener_stats, -1);