Class: Raindrops::Middleware

### Home Classes Methods

### In Files

- lib/raindrops/middleware.rb

### Parent

Object

### Namespace

- CLASS Raindrops::Middleware::Proxy
- CLASS Raindrops::Middleware::Stats

### Methods

- ::new

### Files

- LICENSE
- NEWS
- README

### Class/Module Index

Quicksearch

- Raindrops
- Raindrops::Aggregate
- Raindrops::Aggregate::LastDataRecv
- Raindrops::Aggregate::PMQ
- Raindrops::InetDiagSocket
- Raindrops::LastDataRecv
- Raindrops::Linux
- Raindrops::ListenStats
- Raindrops::Middleware
- Raindrops::Middleware::Proxy
- Raindrops::Middleware::Stats
- Raindrops::Struct
- Raindrops::TCP_Info
- Raindrops::Watcher

No matching classes.

# Raindrops::Middleware

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

    http://raindrops-demo.bogomips.org/_raindrops

Also check out the Watcher demo at raindrops-demo.bogomips.org/

The demo server is only limited to 30 users, so be sure not to abuse it by using the /tail/ endpoint too much.

### Public Class Methods

new(app, opts = {}) click to toggle source

`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)

    # File lib/raindrops/middleware.rb, line 93
    def initialize(app, opts = {})
      @app = app
      @stats = opts[:stats] || Stats.new
      @path = opts[:path] || "/_raindrops"
      tmp = opts[:listeners]
      if tmp.nil? && defined?(Unicorn) && Unicorn.respond_to?(:listener_names)
        tmp = Unicorn.listener_names
      end
      @tcp = @unix = nil

      if tmp
        @tcp = tmp.grep(/\A.+:\d+\z/)
        @unix = tmp.grep(%{\A/})
        @tcp = nil if @tcp.empty?
        @unix = nil if @unix.empty?
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.