raindrops-maintained 0.21.0

data/lib/raindrops/watcher.rb

@@ -0,0 +1,428 @@
+# -*- encoding: binary -*-
+require "thread"
+require "time"
+require "socket"
+require "rack"
+require "aggregate"
+
+# Raindrops::Watcher is a stand-alone Rack application for watching
+# any number of TCP and UNIX listeners (all of them by default).
+#
+# It depends on the {Aggregate RubyGem}[https://rubygems.org/gems/aggregate]
+#
+# In your Rack config.ru:
+#
+#    run Raindrops::Watcher(options = {})
+#
+# It takes the following options hash:
+#
+# - :listeners - an array of listener names, (e.g. %w(0.0.0.0:80 /tmp/sock))
+# - :delay - interval between stats updates in seconds (default: 1)
+#
+# Raindrops::Watcher is compatible any thread-safe/thread-aware Rack
+# middleware.  It does not work well with multi-process web servers
+# but can be used to monitor them.  It consumes minimal resources
+# with the default :delay.
+#
+# == HTTP endpoints
+#
+# === GET /
+#
+# Returns an HTML summary listing of all listen interfaces watched on
+#
+# === GET /active/$LISTENER.txt
+#
+# Returns a plain text summary + histogram with X-* HTTP headers for
+# active connections.
+#
+# e.g.: curl https://yhbt.net/raindrops-demo/active/0.0.0.0%3A80.txt
+#
+# === GET /active/$LISTENER.html
+#
+# Returns an HTML summary + histogram with X-* HTTP headers for
+# active connections.
+#
+# e.g.: curl https://yhbt.net/raindrops-demo/active/0.0.0.0%3A80.html
+#
+# === GET /queued/$LISTENER.txt
+#
+# Returns a plain text summary + histogram with X-* HTTP headers for
+# queued connections.
+#
+# e.g.: curl https://yhbt.net/raindrops-demo/queued/0.0.0.0%3A80.txt
+#
+# === GET /queued/$LISTENER.html
+#
+# Returns an HTML summary + histogram with X-* HTTP headers for
+# queued connections.
+#
+# e.g.: curl https://yhbt.net/raindrops-demo/queued/0.0.0.0%3A80.html
+#
+# === POST /reset/$LISTENER
+#
+# Resets the active and queued statistics for the given listener.
+#
+# === GET /tail/$LISTENER.txt?active_min=1&queued_min=1
+#
+# Streams chunked a response to the client.
+# Interval is the preconfigured +:delay+ of the application (default 1 second)
+#
+# The response is plain text in the following format:
+#
+#   ISO8601_TIMESTAMP LISTENER_NAME ACTIVE_COUNT QUEUED_COUNT LINEFEED
+#
+# Query parameters:
+#
+# - active_min - do not stream a line until this active count is reached
+# - queued_min - do not stream a line until this queued count is reached
+#
+# == Response headers (mostly the same names as Raindrops::LastDataRecv)
+#
+# - X-Count   - number of samples polled
+# - X-Last-Reset - date since the last reset
+#
+# The following headers are only present if X-Count is greater than one.
+#
+# - X-Min     - lowest number of connections recorded
+# - X-Max     - highest number of connections recorded
+# - X-Mean    - mean number of connections recorded
+# - X-Std-Dev - standard deviation of connection count
+# - X-Outliers-Low - number of low outliers (hopefully many for queued)
+# - X-Outliers-High - number of high outliers (hopefully zero for queued)
+# - X-Current - current number of connections
+# - X-First-Peak-At - date of when X-Max was first reached
+# - X-Last-Peak-At - date of when X-Max was last reached
+#
+# = Demo Server
+#
+# There is a server running this app at https://yhbt.net/raindrops-demo/
+# The Raindrops::Middleware demo is also accessible at
+# https://yhbt.net/raindrops-demo/_raindrops
+#
+# 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::Watcher
+  # :stopdoc:
+  attr_reader :snapshot
+  include Rack::Utils
+  include Raindrops::Linux
+  DOC_URL = "https://yhbt.net/raindrops/Raindrops/Watcher.html"
+  Peak = Struct.new(:first, :last)
+
+  def initialize(opts = {})
+    @tcp_listeners = @unix_listeners = nil
+    if l = opts[:listeners]
+      tcp, unix = [], []
+      Array(l).each { |addr| (addr =~ %r{\A/} ? unix : tcp) << addr }
+      unless tcp.empty? && unix.empty?
+        @tcp_listeners = tcp
+        @unix_listeners = unix
+      end
+    end
+
+    @agg_class = opts[:agg_class] || Aggregate
+    @start_time = Time.now.utc
+    @active = Hash.new { |h,k| h[k] = @agg_class.new }
+    @queued = Hash.new { |h,k| h[k] = @agg_class.new }
+    @resets = Hash.new { |h,k| h[k] = @start_time }
+    @peak_active = Hash.new { |h,k| h[k] = Peak.new(@start_time, @start_time) }
+    @peak_queued = Hash.new { |h,k| h[k] = Peak.new(@start_time, @start_time) }
+    @snapshot = [ @start_time, {} ]
+    @delay = opts[:delay] || 1
+    @lock = Mutex.new
+    @start = Mutex.new
+    @cond = ConditionVariable.new
+    @thr = nil
+  end
+
+  def hostname
+    Socket.gethostname
+  end
+
+  # rack endpoint
+  def call(env)
+    @start.synchronize { @thr ||= aggregator_thread(env["rack.logger"]) }
+    case env["REQUEST_METHOD"]
+    when "GET"
+      get env
+    when "HEAD"
+      r = get(env)
+      r[2] = []
+      r
+    when "POST"
+      post env
+    else
+      Rack::Response.new(["Method Not Allowed"], 405).finish
+    end
+  end
+
+  def aggregate!(agg_hash, peak_hash, addr, number, now)
+    agg = agg_hash[addr]
+    if (max = agg.max) && number > 0 && number >= max
+      peak = peak_hash[addr]
+      peak.first = now if number > max
+      peak.last = now
+    end
+    agg << number
+  end
+
+  def aggregator_thread(logger) # :nodoc:
+    @socket = sock = Raindrops::InetDiagSocket.new
+    thr = Thread.new do
+      begin
+        combined = tcp_listener_stats(@tcp_listeners, sock)
+        combined.merge!(unix_listener_stats(@unix_listeners))
+        @lock.synchronize do
+          now = Time.now.utc
+          combined.each do |addr,stats|
+            aggregate!(@active, @peak_active, addr, stats.active, now)
+            aggregate!(@queued, @peak_queued, addr, stats.queued, now)
+          end
+          @snapshot = [ now, combined ]
+          @cond.broadcast
+        end
+      rescue => e
+        logger.error "#{e.class} #{e.inspect}"
+      end while sleep(@delay) && @socket
+      sock.close
+    end
+    wait_snapshot
+    thr
+  end
+
+  def non_existent_stats(time)
+    [ time, @start_time, @agg_class.new, 0, Peak.new(@start_time, @start_time) ]
+  end
+
+  def active_stats(addr) # :nodoc:
+    @lock.synchronize do
+      time, combined = @snapshot
+      stats = combined[addr] or return non_existent_stats(time)
+      tmp, peak = @active[addr], @peak_active[addr]
+      [ time, @resets[addr], tmp.dup, stats.active, peak ]
+    end
+  end
+
+  def queued_stats(addr) # :nodoc:
+    @lock.synchronize do
+      time, combined = @snapshot
+      stats = combined[addr] or return non_existent_stats(time)
+      tmp, peak = @queued[addr], @peak_queued[addr]
+      [ time, @resets[addr], tmp.dup, stats.queued, peak ]
+    end
+  end
+
+  def wait_snapshot
+    @lock.synchronize do
+      @cond.wait @lock
+      @snapshot
+    end
+  end
+
+  def std_dev(agg)
+    agg.std_dev.to_s
+  rescue Errno::EDOM
+    "NaN"
+  end
+
+  def agg_to_hash(reset_at, agg, current, peak)
+    {
+      "X-Count" => agg.count.to_s,
+      "X-Min" => agg.min.to_s,
+      "X-Max" => agg.max.to_s,
+      "X-Mean" => agg.mean.to_s,
+      "X-Std-Dev" => std_dev(agg),
+      "X-Outliers-Low" => agg.outliers_low.to_s,
+      "X-Outliers-High" => agg.outliers_high.to_s,
+      "X-Last-Reset" => reset_at.httpdate,
+      "X-Current" => current.to_s,
+      "X-First-Peak-At" => peak.first.httpdate,
+      "X-Last-Peak-At" => peak.last.httpdate,
+    }
+  end
+
+  def histogram_txt(agg)
+    updated_at, reset_at, agg, current, peak = *agg
+    headers = agg_to_hash(reset_at, agg, current, peak)
+    body = agg.to_s # 7-bit ASCII-clean
+    headers["Content-Type"] = "text/plain"
+    headers["Expires"] = (updated_at + @delay).httpdate
+    headers["Content-Length"] = body.size.to_s
+    [ 200, headers, [ body ] ]
+  end
+
+  def histogram_html(agg, addr)
+    updated_at, reset_at, agg, current, peak = *agg
+    headers = agg_to_hash(reset_at, agg, current, peak)
+    body = "<html>" \
+      "<head><title>#{hostname} - #{escape_html addr}</title></head>" \
+      "<body><table>" <<
+      headers.map { |k,v|
+        "<tr><td>#{k.gsub(/^X-/, '')}</td><td>#{v}</td></tr>"
+      }.join << "</table><pre>#{escape_html agg}</pre>" \
+      "<form action='../reset/#{escape addr}' method='post'>" \
+      "<input type='submit' name='x' value='reset' /></form>" \
+      "</body>"
+    headers["Content-Type"] = "text/html"
+    headers["Expires"] = (updated_at + @delay).httpdate
+    headers["Content-Length"] = body.size.to_s
+    [ 200, headers, [ body ] ]
+  end
+
+  def get(env)
+    retried = false
+    begin
+      case env["PATH_INFO"]
+      when "/"
+        index
+      when %r{\A/active/(.+)\.txt\z}
+        histogram_txt(active_stats(unescape($1)))
+      when %r{\A/active/(.+)\.html\z}
+        addr = unescape $1
+        histogram_html(active_stats(addr), addr)
+      when %r{\A/queued/(.+)\.txt\z}
+        histogram_txt(queued_stats(unescape($1)))
+      when %r{\A/queued/(.+)\.html\z}
+        addr = unescape $1
+        histogram_html(queued_stats(addr), addr)
+      when %r{\A/tail/(.+)\.txt\z}
+        tail(unescape($1), env)
+      else
+        not_found
+      end
+    rescue Errno::EDOM
+      raise if retried
+      retried = true
+      wait_snapshot
+      retry
+    end
+  end
+
+  def not_found
+    Rack::Response.new(["Not Found"], 404).finish
+  end
+
+  def post(env)
+    case env["PATH_INFO"]
+    when %r{\A/reset/(.+)\z}
+      reset!(env, unescape($1))
+    else
+      not_found
+    end
+  end
+
+  def reset!(env, addr)
+    @lock.synchronize do
+      @active.include?(addr) or return not_found
+      @active.delete addr
+      @queued.delete addr
+      @resets[addr] = Time.now.utc
+      @cond.wait @lock
+    end
+    req = Rack::Request.new(env)
+    res = Rack::Response.new
+    url = req.referer || "#{req.host_with_port}/"
+    res.redirect(url)
+    res["Content-Type"] = "text/plain"
+    res.write "Redirecting to #{url}"
+    res.finish
+  end
+
+  def index
+    updated_at, all = snapshot
+    headers = {
+      "Content-Type" => "text/html",
+      "Last-Modified" => updated_at.httpdate,
+      "Expires" => (updated_at + @delay).httpdate,
+    }
+    body = "<html><head>" \
+      "<title>#{hostname} - all interfaces</title>" \
+      "</head><body><h3>Updated at #{updated_at.iso8601}</h3>" \
+      "<table><tr>" \
+        "<th>address</th><th>active</th><th>queued</th><th>reset</th>" \
+      "</tr>" <<
+      all.sort do |a,b|
+        a[0] <=> b[0] # sort by addr
+      end.map do |addr,stats|
+        e_addr = escape addr
+        "<tr>" \
+          "<td><a href='tail/#{e_addr}.txt' " \
+            "title='&quot;tail&quot; output in real time'" \
+            ">#{escape_html addr}</a></td>" \
+          "<td><a href='active/#{e_addr}.html' " \
+            "title='show active connection stats'>#{stats.active}</a></td>" \
+          "<td><a href='queued/#{e_addr}.html' " \
+            "title='show queued connection stats'>#{stats.queued}</a></td>" \
+          "<td><form action='reset/#{e_addr}' method='post'>" \
+            "<input title='reset statistics' " \
+              "type='submit' name='x' value='x' /></form></td>" \
+        "</tr>" \
+      end.join << "</table>" \
+      "<p>" \
+        "This is running the #{self.class}</a> service, see " \
+        "<a href='#{DOC_URL}'>#{DOC_URL}</a> " \
+        "for more information and options." \
+      "</p>" \
+      "</body></html>"
+    headers["Content-Length"] = body.size.to_s
+    [ 200, headers, [ body ] ]
+  end
+
+  def tail(addr, env)
+    Tailer.new(self, addr, env).finish
+  end
+
+  # This is the response body returned for "/tail/$ADDRESS.txt".  This
+  # must use a multi-threaded Rack server with streaming response support.
+  # It is an internal class and not expected to be used directly
+  class Tailer
+    def initialize(rdmon, addr, env) # :nodoc:
+      @rdmon = rdmon
+      @addr = addr
+      q = Rack::Utils.parse_query env["QUERY_STRING"]
+      @active_min = q["active_min"].to_i
+      @queued_min = q["queued_min"].to_i
+      len = addr.size
+      len = 35 if len > 35
+      @fmt = "%20s % #{len}s % 10u % 10u\n"
+      case env["HTTP_VERSION"]
+      when "HTTP/1.0", nil
+        @chunk = false
+      else
+        @chunk = true
+      end
+    end
+
+    def finish
+      headers = {
+        "Content-Type" => "text/plain",
+        "Cache-Control" => "no-transform",
+        "Expires" => Time.at(0).httpdate,
+      }
+      headers["Transfer-Encoding"] = "chunked" if @chunk
+      [ 200, headers, self ]
+    end
+
+    # called by the Rack server
+    def each # :nodoc:
+      begin
+        time, all = @rdmon.wait_snapshot
+        stats = all[@addr] or next
+        stats.queued >= @queued_min or next
+        stats.active >= @active_min or next
+        body = sprintf(@fmt, time.iso8601, @addr, stats.active, stats.queued)
+        body = "#{body.size.to_s(16)}\r\n#{body}\r\n" if @chunk
+        yield body
+      end while true
+      yield "0\r\n\r\n" if @chunk
+    end
+  end
+
+  # shuts down the background thread, only for tests
+  def shutdown
+    @socket = nil
+    @thr.join if @thr
+    @thr = nil
+  end
+  # :startdoc:
+end

data/lib/raindrops.rb

@@ -0,0 +1,72 @@
+# -*- encoding: binary -*-
+#
+# Each Raindrops object is a container that holds several counters.
+# It is internally a page-aligned, shared memory area that allows
+# atomic increments, decrements, assignments and reads without any
+# locking.
+#
+#   rd = Raindrops.new 4
+#   rd.incr(0, 1)   -> 1
+#   rd.to_ary       -> [ 1, 0, 0, 0 ]
+#
+# Unlike many classes in this package, the core Raindrops class is
+# intended to be portable to all reasonably modern *nix systems
+# supporting mmap().  Please let us know if you have portability
+# issues, patches or pull requests at mailto:raindrops-public@yhbt.net
+class Raindrops
+
+  # 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 unless defined? ListenStats
+
+  # call-seq:
+  #	Raindrops.new(size, io: nil)	-> raindrops object
+  #
+  # Initializes a Raindrops object to hold +size+ counters.  +size+ is
+  # only a hint and the actual number of counters the object has is
+  # dependent on the CPU model, number of cores, and page size of
+  # the machine.  The actual size of the object will always be equal
+  # or greater than the specified +size+.
+  # If +io+ is provided, then the Raindrops memory will be backed by
+  # the specified file; otherwise, it will allocate anonymous memory.
+  # The IO object must respond to +truncate+, as this is used to set
+  # the size of the file.
+  # If +zero+ is provided, then the memory region is zeroed prior to
+  # returning. This is only meaningful if +io+ is also provided; in
+  # that case it controls whether any existing counter values in +io+
+  # are retained (false) or whether it is entirely zeroed (true).
+  def initialize(size, io: nil, zero: false)
+    # This ruby wrapper exists to handle the keyword-argument handling,
+    # which is otherwise kind of awkward in C. We delegate the keyword
+    # arguments to the _actual_ initialize implementation as positional
+    # args.
+    initialize_cimpl(size, io, zero)
+  end
+
+  autoload :Linux, 'raindrops/linux'
+  autoload :Struct, 'raindrops/struct'
+  autoload :Middleware, 'raindrops/middleware'
+  autoload :Aggregate, 'raindrops/aggregate'
+  autoload :LastDataRecv, 'raindrops/last_data_recv'
+  autoload :Watcher, 'raindrops/watcher'
+end
+require 'raindrops_ext'

data/pkg.mk

@@ -0,0 +1,151 @@
+RUBY = ruby
+RAKE = rake
+RSYNC = rsync
+OLDDOC = olddoc
+RDOC = rdoc
+
+GIT-VERSION-FILE: .FORCE-GIT-VERSION-FILE
+	@./GIT-VERSION-GEN
+-include GIT-VERSION-FILE
+-include local.mk
+DLEXT := $(shell $(RUBY) -rrbconfig -e 'puts RbConfig::CONFIG["DLEXT"]')
+RUBY_VERSION := $(shell $(RUBY) -e 'puts RUBY_VERSION')
+RUBY_ENGINE := $(shell $(RUBY) -e 'puts((RUBY_ENGINE rescue "ruby"))')
+lib := lib
+
+ext := $(firstword $(wildcard ext/*))
+ifneq ($(ext),)
+ext_pfx := tmp/ext/$(RUBY_ENGINE)-$(RUBY_VERSION)
+ext_h := $(wildcard $(ext)/*/*.h $(ext)/*.h)
+ext_src := $(wildcard $(ext)/*.c $(ext_h))
+ext_pfx_src := $(addprefix $(ext_pfx)/,$(ext_src))
+ext_d := $(ext_pfx)/$(ext)/.d
+$(ext)/extconf.rb: $(wildcard $(ext)/*.h)
+	@>> $@
+$(ext_d):
+	@mkdir -p $(@D)
+	@> $@
+$(ext_pfx)/$(ext)/%: $(ext)/% $(ext_d)
+	install -m 644 $< $@
+$(ext_pfx)/$(ext)/Makefile: $(ext)/extconf.rb $(ext_d) $(ext_h)
+	$(RM) -f $(@D)/*.o
+	cd $(@D) && $(RUBY) $(CURDIR)/$(ext)/extconf.rb $(EXTCONF_ARGS)
+ext_sfx := _ext.$(DLEXT)
+ext_dl := $(ext_pfx)/$(ext)/$(notdir $(ext)_ext.$(DLEXT))
+$(ext_dl): $(ext_src) $(ext_pfx_src) $(ext_pfx)/$(ext)/Makefile
+	@echo $^ == $@
+	$(MAKE) -C $(@D)
+lib := $(lib):$(ext_pfx)/$(ext)
+build: $(ext_dl)
+else
+build:
+endif
+
+pkg_extra += GIT-VERSION-FILE NEWS LATEST
+NEWS: GIT-VERSION-FILE .olddoc.yml
+	$(OLDDOC) prepare
+LATEST: NEWS
+
+manifest:
+	$(RM) .manifest
+	$(MAKE) .manifest
+
+.manifest: $(pkg_extra)
+	(git ls-files && for i in $@ $(pkg_extra); do echo $$i; done) | \
+		LC_ALL=C sort > $@+
+	cmp $@+ $@ || mv $@+ $@
+	$(RM) $@+
+
+doc:: .document .olddoc.yml $(pkg_extra) $(PLACEHOLDERS)
+	-find lib -type f -name '*.rbc' -exec rm -f '{}' ';'
+	-find ext -type f -name '*.rbc' -exec rm -f '{}' ';'
+	$(RM) -r doc
+	$(RDOC) -f dark216
+	$(OLDDOC) merge
+	install -m644 COPYING doc/COPYING
+	install -m644 NEWS doc/NEWS
+	install -m644 NEWS.atom.xml doc/NEWS.atom.xml
+	install -m644 $(shell LC_ALL=C grep '^[A-Z]' .document) doc/
+
+ifneq ($(VERSION),)
+pkggem := pkg/$(rfpackage)-$(VERSION).gem
+pkgtgz := pkg/$(rfpackage)-$(VERSION).tgz
+
+# ensures we're actually on the tagged $(VERSION), only used for release
+verify:
+	test x"$(shell umask)" = x0022
+	git rev-parse --verify refs/tags/v$(VERSION)^{}
+	git diff-index --quiet HEAD^0
+	test $$(git rev-parse --verify HEAD^0) = \
+	     $$(git rev-parse --verify refs/tags/v$(VERSION)^{})
+
+fix-perms:
+	-git ls-tree -r HEAD | awk '/^100644 / {print $$NF}' | xargs chmod 644
+	-git ls-tree -r HEAD | awk '/^100755 / {print $$NF}' | xargs chmod 755
+
+gem: $(pkggem)
+
+install-gem: $(pkggem)
+	gem install --local $(CURDIR)/$<
+
+$(pkggem): manifest fix-perms
+	gem build $(rfpackage).gemspec
+	mkdir -p pkg
+	mv $(@F) $@
+
+$(pkgtgz): distdir = $(basename $@)
+$(pkgtgz): HEAD = v$(VERSION)
+$(pkgtgz): manifest fix-perms
+	@test -n "$(distdir)"
+	$(RM) -r $(distdir)
+	mkdir -p $(distdir)
+	tar cf - $$(cat .manifest) | (cd $(distdir) && tar xf -)
+	cd pkg && tar cf - $(basename $(@F)) | gzip -9 > $(@F)+
+	mv $@+ $@
+
+package: $(pkgtgz) $(pkggem)
+
+release:: verify package
+	# push gem to RubyGems.org
+	gem push $(pkggem)
+else
+gem install-gem: GIT-VERSION-FILE
+	$(MAKE) $@ VERSION=$(GIT_VERSION)
+endif
+
+all:: check
+test_units := $(wildcard test/test_*.rb)
+test: check
+check: test-unit
+test-unit: $(test_units)
+$(test_units): build
+	$(RUBY) -I $(lib) $@ $(RUBY_TEST_OPTS)
+
+# this requires GNU coreutils variants
+ifneq ($(RSYNC_DEST),)
+publish_doc:
+	-git set-file-times
+	$(MAKE) doc
+	$(MAKE) doc_gz
+	$(RSYNC) -av doc/ $(RSYNC_DEST)/ \
+		--exclude index.html* --exclude created.rid*
+	git ls-files | xargs touch
+endif
+
+# Create gzip variants of the same timestamp as the original so nginx
+# "gzip_static on" can serve the gzipped versions directly.
+doc_gz: docs = $(shell find doc -type f ! -regex '^.*\.gz$$')
+doc_gz:
+	for i in $(docs); do \
+	  gzip --rsyncable -9 < $$i > $$i.gz; touch -r $$i $$i.gz; done
+check-warnings:
+	@(for i in $$(git ls-files '*.rb'| grep -v '^setup\.rb$$'); \
+	  do $(RUBY) -d -W2 -c $$i; done) | grep -v '^Syntax OK$$' || :
+
+ifneq ($(PLACEHOLDERS),)
+$(PLACEHOLDERS):
+	echo olddoc_placeholder > $@
+endif
+
+.PHONY: all .FORCE-GIT-VERSION-FILE doc check test $(test_units) manifest
+.PHONY: check-warnings

data/raindrops-maintained.gemspec

@@ -0,0 +1 @@
+raindrops.gemspec

data/raindrops.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: binary -*-
+manifest = File.exist?('.manifest') ?
+  IO.readlines('.manifest').map!(&:chomp!) : `git ls-files`.split("\n")
+test_files = manifest.grep(%r{\Atest/test_.*\.rb\z})
+
+Gem::Specification.new do |s|
+  s.name = "raindrops-maintained"
+  s.version = (ENV["VERSION"] ||= '0.21.0').dup
+  s.authors = ["raindrops hackers"]
+  s.description = File.read('README').split("\n\n")[1]
+  s.email = %q{raindrops-public@yhbt.net}
+  s.extensions = %w(ext/raindrops/extconf.rb)
+  s.extra_rdoc_files = IO.readlines('.document').map!(&:chomp!).keep_if do |f|
+    File.exist?(f)
+  end
+  s.files = manifest
+  s.homepage = 'https://yhbt.net/raindrops/'
+  s.summary = 'real-time stats for preforking Rack servers'
+  s.required_ruby_version = '>= 1.9.3'
+  s.test_files = test_files
+  s.add_development_dependency('aggregate', '~> 0.2')
+  s.add_development_dependency('test-unit', '~> 3.0')
+  s.add_development_dependency('posix_mq', '~> 2.0')
+  s.add_development_dependency('rack', [ '>= 1.2', '< 4' ])
+  s.licenses = %w(LGPL-2.1+)
+end