raindrops-maintained 0.21.0

data/test/test_raindrops_gc.rb

@@ -0,0 +1,38 @@
+# -*- encoding: binary -*-
+require 'test/unit'
+require 'raindrops'
+
+class TestRaindropsGc < Test::Unit::TestCase
+
+  # we may need to create more garbage as GC may be less aggressive
+  # about expiring things.  This is completely unrealistic code,
+  # though...
+  def test_gc
+    assert_nothing_raised do
+      1000000.times { |i| Raindrops.new(24); [] }
+    end
+  end
+
+  def test_gc_postfork
+    tmp = Raindrops.new 2
+    pid = fork do
+      1000000.times do
+        tmp = Raindrops.new 2
+        tmp.to_ary
+      end
+    end
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    assert_equal [ 0, 0 ], tmp.to_ary
+    tmp.incr 1
+    assert_equal [ 0, 1 ], tmp.to_ary
+    pid = fork do
+      tmp.incr 1
+      exit([ 0, 2 ] == tmp.to_ary)
+    end
+    _, status = Process.waitpid2(pid)
+    assert status.success?
+    assert_equal [ 0, 2 ], tmp.to_ary
+  end
+end if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" &&
+       ENV["STRESS"].to_i != 0

data/test/test_struct.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+require 'raindrops'
+
+class TestRaindrops < Test::Unit::TestCase
+
+  def test_struct_new
+    @rw = Raindrops::Struct.new(:r, :w)
+    assert @rw.kind_of?(Class)
+  end
+
+  TMP = Raindrops::Struct.new(:r, :w)
+
+  def test_init_basic
+    tmp = TMP.new
+    assert_equal 0, tmp.r
+    assert_equal 1, tmp.incr_r
+    assert_equal 1, tmp.r
+    assert_equal({ :r => 1, :w => 0 }, tmp.to_hash)
+
+    assert_equal 1, tmp[0]
+    assert_equal 0, tmp[1]
+    assert_equal [ :r, :w ], TMP::MEMBERS
+  end
+
+  def test_init
+    tmp = TMP.new(5, 6)
+    assert_equal({ :r => 5, :w => 6 }, tmp.to_hash)
+  end
+
+  def test_dup
+    a = TMP.new(5, 6)
+    b = a.dup
+    assert_equal({ :r => 5, :w => 6 }, b.to_hash)
+    assert_nothing_raised { 4.times { b.decr_r } }
+    assert_equal({ :r => 1, :w => 6 }, b.to_hash)
+    assert_equal({ :r => 5, :w => 6 }, a.to_hash)
+  end
+
+  class Foo < Raindrops::Struct.new(:a, :b, :c, :d)
+    def to_ary
+      @raindrops.to_ary
+    end
+
+    def hello
+      "world"
+    end
+  end
+
+  def test_subclass
+    assert_equal [0, 0, 0, 0], Foo.new.to_ary
+    assert_equal "world", Foo.new.hello
+  end
+
+end

data/test/test_tcp_info.rb

@@ -0,0 +1,88 @@
+# -*- encoding: binary -*-
+require 'test/unit'
+require 'tempfile'
+require 'raindrops'
+require 'socket'
+require 'pp'
+$stderr.sync = $stdout.sync = true
+class TestTCP_Info < Test::Unit::TestCase
+
+  TEST_ADDR = ENV['UNICORN_TEST_ADDR'] || '127.0.0.1'
+
+  # Linux kernel commit 5ee3afba88f5a79d0bff07ddd87af45919259f91
+  TCP_INFO_useful_listenq = `uname -r`.strip >= '2.6.24'
+
+  def test_tcp_server_unacked
+    return if RUBY_PLATFORM !~ /linux/ # unacked not implemented on others...
+    s = TCPServer.new(TEST_ADDR, 0)
+    rv = Raindrops::TCP_Info.new s
+    c = TCPSocket.new TEST_ADDR, s.addr[1]
+    tmp = Raindrops::TCP_Info.new s
+    TCP_INFO_useful_listenq and assert_equal 1, tmp.unacked
+
+    assert_equal 0, rv.unacked
+    a = s.accept
+    tmp = Raindrops::TCP_Info.new s
+    assert_equal 0, tmp.unacked
+    before = tmp.object_id
+
+    tmp.get!(s)
+    assert_equal before, tmp.object_id
+
+  ensure
+    [ c, a, s ].compact.each(&:close)
+  end
+
+  def test_accessors
+    s = TCPServer.new TEST_ADDR, 0
+    tmp = Raindrops::TCP_Info.new s
+    tcp_info_methods = tmp.methods - Object.new.methods
+    assert tcp_info_methods.size >= 32
+    tcp_info_methods.each do |m|
+      next if m.to_sym == :get!
+      next if ! tmp.respond_to?(m)
+      val = tmp.__send__ m
+      assert_kind_of Integer, val
+      assert val >= 0
+    end
+    assert tmp.respond_to?(:state), 'every OS knows about TCP state, right?'
+  ensure
+    s.close
+  end
+
+  def test_tcp_server_delayed
+    delay = 0.010
+    delay_ms = (delay * 1000).to_i
+    s = TCPServer.new(TEST_ADDR, 0)
+    c = TCPSocket.new TEST_ADDR, s.addr[1]
+    c.syswrite "."
+    sleep(delay * 1.2)
+    a = s.accept
+    i = Raindrops::TCP_Info.new(a)
+    assert i.last_data_recv >= delay_ms, "#{i.last_data_recv} < #{delay_ms}"
+  ensure
+    c.close if c
+    a.close if a
+    s.close
+  end
+
+  def test_tcp_server_state_closed
+    s = TCPServer.new(TEST_ADDR, 0)
+    c = TCPSocket.new(TEST_ADDR, s.addr[1])
+    i = Raindrops::TCP_Info.allocate
+    a = s.accept
+    i.get!(a)
+    state = i.state
+    if Raindrops.const_defined?(:TCP)
+      assert_equal state, Raindrops::TCP[:ESTABLISHED]
+    end
+    c = c.close
+    sleep(0.01) # wait for kernel to update state
+    i.get!(a)
+    assert_not_equal state, i.state
+  ensure
+    s.close if s
+    c.close if c
+    a.close if a
+  end
+end if defined? Raindrops::TCP_Info

data/test/test_watcher.rb

@@ -0,0 +1,186 @@
+# -*- encoding: binary -*-
+require "test/unit"
+require "raindrops"
+begin
+  require 'aggregate'
+  require 'rack'
+rescue LoadError => e
+  warn "W: #{e} skipping #{__FILE__}"
+end
+
+class TestWatcher < Test::Unit::TestCase
+  TEST_ADDR = ENV['UNICORN_TEST_ADDR'] || '127.0.0.1'
+  def check_headers(headers)
+    %w(X-Count X-Std-Dev X-Min X-Max X-Mean
+       X-Outliers-Low X-Outliers-Low X-Last-Reset).each { |x|
+      assert_kind_of String, headers[x], "#{x} missing"
+    }
+  end
+
+  def teardown
+    @app.shutdown
+    @ios.each { |io| io.close unless io.closed? }
+  end
+
+  def setup
+    @ios = []
+    @srv = TCPServer.new TEST_ADDR, 0
+    @ios << @srv
+    @port = @srv.addr[1]
+    @client = TCPSocket.new TEST_ADDR, @port
+    @addr = "#{TEST_ADDR}:#{@port}"
+    @ios << @client
+    @app = Raindrops::Watcher.new :delay => 0.001
+    @req = Rack::MockRequest.new @app
+  end
+
+  def test_index
+    resp = @req.get "/"
+    assert_equal 200, resp.status.to_i
+    t = Time.parse resp.headers["Last-Modified"]
+    assert_in_delta Time.now.to_f, t.to_f, 2.0
+  end
+
+  def test_active_txt
+    resp = @req.get "/active/#@addr.txt"
+    assert_equal 200, resp.status.to_i
+    assert_equal "text/plain", resp.headers["Content-Type"]
+    check_headers(resp.headers)
+  end
+
+  def test_invalid
+    assert_nothing_raised do
+      @req.get("/active/666.666.666.666%3A666.txt")
+      @req.get("/queued/666.666.666.666%3A666.txt")
+      @req.get("/active/666.666.666.666%3A666.html")
+      @req.get("/queued/666.666.666.666%3A666.html")
+    end
+    addr = @app.instance_eval do
+      @peak_active.keys + @peak_queued.keys +
+         @resets.keys + @active.keys + @queued.keys
+    end
+    assert addr.grep(/666\.666\.666\.666/).empty?, addr.inspect
+  end
+
+  def test_active_html
+    resp = @req.get "/active/#@addr.html"
+    assert_equal 200, resp.status.to_i
+    assert_equal "text/html", resp.headers["Content-Type"]
+    check_headers(resp.headers)
+  end
+
+  def test_queued_txt
+    resp = @req.get "/queued/#@addr.txt"
+    assert_equal 200, resp.status.to_i
+    assert_equal "text/plain", resp.headers["Content-Type"]
+    check_headers(resp.headers)
+  end
+
+  def test_queued_html
+    resp = @req.get "/queued/#@addr.html"
+    assert_equal 200, resp.status.to_i
+    assert_equal "text/html", resp.headers["Content-Type"]
+    check_headers(resp.headers)
+  end
+
+  def test_reset
+    resp = @req.post "/reset/#@addr"
+    assert_equal 302, resp.status.to_i
+  end
+
+  def test_tail
+    env = @req.class.env_for "/tail/#@addr.txt"
+    status, headers, body = @app.call env
+    assert_equal "text/plain", headers["Content-Type"]
+    assert_equal 200, status.to_i
+    tmp = []
+    body.each do |x|
+      assert_kind_of String, x
+      tmp << x
+      break if tmp.size > 1
+    end
+  end
+
+  def test_tail_queued_min
+    env = @req.class.env_for "/tail/#@addr.txt?queued_min=1"
+    status, headers, body = @app.call env
+    assert_equal "text/plain", headers["Content-Type"]
+    assert_equal 200, status.to_i
+    tmp = []
+    body.each do |x|
+      tmp = TCPSocket.new TEST_ADDR, @port
+      @ios << tmp
+      assert_kind_of String, x
+      assert_equal 1, x.strip.split(/\s+/).last.to_i
+      break
+    end
+  end
+
+  def test_x_current_header
+    env = @req.class.env_for "/active/#@addr.txt"
+    _status, headers, _body = @app.call(env)
+    assert_equal "0", headers["X-Current"], headers.inspect
+
+    env = @req.class.env_for "/queued/#@addr.txt"
+    _status, headers, _body = @app.call(env)
+    assert_equal "1", headers["X-Current"], headers.inspect
+
+    @ios << @srv.accept
+    sleep 0.1
+
+    env = @req.class.env_for "/queued/#@addr.txt"
+    _status, headers, _body = @app.call(env)
+    assert_equal "0", headers["X-Current"], headers.inspect
+
+    env = @req.class.env_for "/active/#@addr.txt"
+    _status, headers, _body = @app.call(env)
+    assert_equal "1", headers["X-Current"], headers.inspect
+  end
+
+  def test_peaks
+    env = @req.class.env_for "/active/#@addr.txt"
+    _status, headers, _body = @app.call(env.dup)
+    start = headers["X-First-Peak-At"]
+    assert headers["X-First-Peak-At"], headers.inspect
+    assert headers["X-Last-Peak-At"], headers.inspect
+    assert_nothing_raised { Time.parse(headers["X-First-Peak-At"]) }
+    assert_nothing_raised { Time.parse(headers["X-Last-Peak-At"]) }
+    before = headers["X-Last-Peak-At"]
+
+    env = @req.class.env_for "/queued/#@addr.txt"
+    _status, headers, _body = @app.call(env)
+    assert_nothing_raised { Time.parse(headers["X-First-Peak-At"]) }
+    assert_nothing_raised { Time.parse(headers["X-Last-Peak-At"]) }
+    assert_equal before, headers["X-Last-Peak-At"], "should not change"
+
+    sleep 2
+    env = @req.class.env_for "/active/#@addr.txt"
+    _status, headers, _body = @app.call(env.dup)
+    assert_equal before, headers["X-Last-Peak-At"], headers.inspect
+
+    @ios << @srv.accept
+    begin
+      @srv.accept_nonblock
+      assert false, "we should not get here"
+    rescue => e
+      assert_kind_of Errno::EAGAIN, e
+    end
+    sleep 0.1
+    env = @req.class.env_for "/queued/#@addr.txt"
+    _status, headers, _body = @app.call(env.dup)
+    assert headers["X-Last-Peak-At"], headers.inspect
+    assert_nothing_raised { Time.parse(headers["X-Last-Peak-At"]) }
+    assert before != headers["X-Last-Peak-At"]
+
+    queued_before = headers["X-Last-Peak-At"]
+
+    sleep 2
+
+    env = @req.class.env_for "/queued/#@addr.txt"
+    _status, headers, _body = @app.call(env)
+    assert_equal "0", headers["X-Current"]
+    assert_nothing_raised { Time.parse(headers["X-Last-Peak-At"]) }
+    assert_equal queued_before, headers["X-Last-Peak-At"], "should not change"
+    assert_equal start, headers["X-First-Peak-At"]
+  end
+end if RUBY_PLATFORM =~ /linux/ && defined?(Aggregate) && defined?(Rack)

metadata

@@ -0,0 +1,193 @@
+--- !ruby/object:Gem::Specification
+name: raindrops-maintained
+version: !ruby/object:Gem::Version
+  version: 0.21.0
+platform: ruby
+authors:
+- raindrops hackers
+bindir: bin
+cert_chain: []
+date: 2024-03-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aggregate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: posix_mq
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4'
+description: |-
+  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.
+email: raindrops-public@yhbt.net
+executables: []
+extensions:
+- ext/raindrops/extconf.rb
+extra_rdoc_files:
+- README
+- LICENSE
+- NEWS
+- ext/raindrops/raindrops.c
+- ext/raindrops/linux_inet_diag.c
+- ext/raindrops/tcp_info.c
+files:
+- ".document"
+- ".gitattributes"
+- ".gitignore"
+- ".manifest"
+- ".olddoc.yml"
+- COPYING
+- GIT-VERSION-FILE
+- GIT-VERSION-GEN
+- GNUmakefile
+- LATEST
+- LICENSE
+- NEWS
+- README
+- TODO
+- archive/.gitignore
+- archive/slrnpull.conf
+- examples/linux-listener-stats.rb
+- examples/middleware.ru
+- examples/watcher.ru
+- examples/watcher_demo.ru
+- examples/yahns.conf.rb
+- examples/zbatery.conf.rb
+- ext/raindrops/extconf.rb
+- ext/raindrops/linux_inet_diag.c
+- ext/raindrops/my_fileno.h
+- ext/raindrops/raindrops.c
+- ext/raindrops/raindrops_atomic.h
+- ext/raindrops/tcp_info.c
+- lib/raindrops.rb
+- lib/raindrops/aggregate.rb
+- lib/raindrops/aggregate/last_data_recv.rb
+- lib/raindrops/aggregate/pmq.rb
+- lib/raindrops/last_data_recv.rb
+- lib/raindrops/linux.rb
+- lib/raindrops/middleware.rb
+- lib/raindrops/middleware/proxy.rb
+- lib/raindrops/struct.rb
+- lib/raindrops/watcher.rb
+- pkg.mk
+- raindrops-maintained.gemspec
+- raindrops.gemspec
+- setup.rb
+- test/ipv6_enabled.rb
+- test/rack_unicorn.rb
+- test/test_aggregate_pmq.rb
+- test/test_inet_diag_socket.rb
+- test/test_last_data_recv.rb
+- test/test_last_data_recv_unicorn.rb
+- test/test_linux.rb
+- test/test_linux_all_tcp_listen_stats.rb
+- test/test_linux_all_tcp_listen_stats_leak.rb
+- test/test_linux_ipv6.rb
+- test/test_linux_middleware.rb
+- test/test_linux_reuseport_tcp_listen_stats.rb
+- test/test_middleware.rb
+- test/test_middleware_unicorn.rb
+- test/test_middleware_unicorn_ipv6.rb
+- test/test_raindrops.rb
+- test/test_raindrops_gc.rb
+- test/test_struct.rb
+- test/test_tcp_info.rb
+- test/test_watcher.rb
+homepage: https://yhbt.net/raindrops/
+licenses:
+- LGPL-2.1+
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.0.dev
+specification_version: 4
+summary: real-time stats for preforking Rack servers
+test_files:
+- test/test_aggregate_pmq.rb
+- test/test_inet_diag_socket.rb
+- test/test_last_data_recv.rb
+- test/test_last_data_recv_unicorn.rb
+- test/test_linux.rb
+- test/test_linux_all_tcp_listen_stats.rb
+- test/test_linux_all_tcp_listen_stats_leak.rb
+- test/test_linux_ipv6.rb
+- test/test_linux_middleware.rb
+- test/test_linux_reuseport_tcp_listen_stats.rb
+- test/test_middleware.rb
+- test/test_middleware_unicorn.rb
+- test/test_middleware_unicorn_ipv6.rb
+- test/test_raindrops.rb
+- test/test_raindrops_gc.rb
+- test/test_struct.rb
+- test/test_tcp_info.rb
+- test/test_watcher.rb