LICENSE NEWS README
Raindrops Aggregate Aggregate::LastDataRecv Aggregate::PMQ InetDiagSocket LastDataRecv Linux ListenStats Middleware Middleware::Proxy Struct TCP_Info Watcher

Methods

::new #<< #aggregate #count #each #each_nonzero #flush #flush_master #master_loop #max #mean #min #outliers_high #outliers_low #std_dev #stop_master_loop #sum #to_s

class Raindrops::Aggregate::PMQ

Aggregate + POSIX message queues support for Ruby 1.9+ and Linux

This class is duck-type compatible with Aggregate and allows us to aggregate and share statistics from multiple processes/threads aided POSIX message queues. This is designed to be used with the Raindrops::LastDataRecv Rack application, but can be used independently on compatible Runtimes.

Unlike the core of raindrops, this is only supported on Ruby 1.9+ and Linux 2.6+. Using this class requires the following additional RubyGems or libraries:

Design

There is one master thread which aggregates statistics. Individual worker processes or threads will write to a shared POSIX message queue (default: "/raindrops") that the master reads from. At a predefined interval, the master thread will write out to a shared, anonymous temporary file that workers may read from

Setting :worker_interval and :master_interval to 1 will result in perfect accuracy but at the cost of a high synchronization overhead. Larger intervals mean less frequent messaging for higher performance but lower accuracy.

Attributes

nr_dropped [R]

returns the number of dropped messages sent to a POSIX message queue if non-blocking operation was desired with :lossy

Public Class Methods

new (params = {}) source

Creates a new Raindrops::Aggregate::PMQ object

Raindrops::Aggregate::PMQ.new(options = {})  -> aggregate

options is a hash that accepts the following keys:

Public Instance Methods

<< (val) source

adds a sample to the underlying Aggregate object

aggregate () source

Loads the last shared Aggregate from the master thread/process

count () source

proxy for Aggregate#count

each () { |*args| ... } source

proxy for Aggregate#each

each_nonzero () { |*args| ... } source

proxy for Aggregate#each_nonzero

flush () source

flushes the local queue of the worker process, sending all pending data to the master. There is no need to call this explicitly as :worker_interval defines how frequently your queue will be flushed

flush_master () source

Flushes the currently aggregate statistics to a temporary file. There is no need to call this explicitly as :worker_interval defines how frequently your data will be flushed for workers to read.

master_loop () source

Starts running a master loop, usually in a dedicated thread or process:

Thread.new { agg.master_loop }

Any worker can call agg.stop_master_loop to stop the master loop (possibly causing the thread or process to exit)

max () source

proxy for Aggregate#max

mean () source

proxy for Aggregate#mean

min () source

proxy for Aggregate#min

outliers_high () source

proxy for Aggregate#outliers_high

outliers_low () source

proxy for Aggregate#outliers_low

std_dev () source

proxy for Aggregate#std_dev

stop_master_loop () source

stops the currently running master loop, may be called from any worker thread or process

sum () source

proxy for Aggregate#sum

to_s (*args) source

proxy for Aggregate#to_s


Pages Classes Methods
mail archives: https://bogomips.org/raindrops-public/
	http://ou63pmih66umazou.onion/raindrops-public 
	nntp://news.public-inbox.org/inbox.comp.lang.ruby.raindrops 
	nntp://ou63pmih66umazou.onion/inbox.comp.lang.ruby.raindrops 
public: raindrops-public@bogomips.org
source code: git clone git://bogomips.org/raindrops.git
	git clone https://bogomips.org/raindrops.git