Class: Raptor::Stats

Inherits:
Object
  • Object
show all
Defined in:
lib/raptor/stats.rb,
sig/generated/raptor/stats.rbs

Overview

Shared-memory store for per-worker process statistics. Each worker holds a fixed-size slot in an anonymous mmap region.

Binary layout per slot (native byte order):

pid               uint32    4 bytes
index             uint32    4 bytes
phase             uint32    4 bytes
requests          uint64    8 bytes
backlog           uint32    4 bytes
busy_threads      uint32    4 bytes
thread_capacity   uint32    4 bytes
started_at        float64   8 bytes
last_checkin      float64   8 bytes
booted            uint8     1 byte
                         49 bytes total

Constant Summary collapse

SLOT_FORMAT =

Returns:

  • (::String) 
"LLLQLLLddC"
SLOT_SIZE =

Returns:

  • (Object) 
[0, 0, 0, 0, 0, 0, 0, 0.0, 0.0, 0].pack(SLOT_FORMAT).bytesize

Instance Method Summary collapse

Constructor Details

#initialize(num_workers) ⇒ Stats

Allocates the shared mmap region for num_workers slots.

Parameters:

  • num_workers (Integer) —

    number of worker slots to allocate



36
37
38
39
 
# File 'lib/raptor/stats.rb', line 36

def initialize(num_workers)
  @num_workers = num_workers
  @mmap = Mmap.new(nil, length: num_workers * SLOT_SIZE, initialize: "\0")
end

Instance Method Details

#all ⇒ Array<Hash>

Returns stats for all worker slots.

Returns:

  • (Array<Hash>) —

    per-worker stat hashes with :pid, :index, :phase, :requests, :backlog, :busy_threads, :thread_capacity, :started_at, :last_checkin, and :booted



66
67
68
 
# File 'lib/raptor/stats.rb', line 66

def all
  (0...@num_workers).map { |index| read(index) }
end

#read(slot) ⇒ Hash

Reads stats for a worker slot from shared memory.

Parameters:

  • slot (Integer) —

    slot offset to read from

Returns:

  • (Hash) —

    stat hash with :pid, :index, :phase, :requests, :backlog, :busy_threads, :thread_capacity, :started_at, :last_checkin, and :booted



87
88
89
90
91
 
# File 'lib/raptor/stats.rb', line 87

def read(slot)
  data = @mmap[slot * SLOT_SIZE, SLOT_SIZE]
  pid, index, phase, requests, backlog, busy_threads, thread_capacity, started_at, last_checkin, booted = data.unpack(SLOT_FORMAT)
  { pid:, index:, phase:, requests:, backlog:, busy_threads:, thread_capacity:, started_at:, last_checkin:, booted: booted == 1 }
end

#unmap ⇒ void

This method returns an undefined value.

Releases the shared memory mapping.



75
76
77
 
# File 'lib/raptor/stats.rb', line 75

def unmap
  @mmap.unmap
end

#write(index, pid:, phase:, requests:, backlog:, busy_threads:, thread_capacity:, started_at:, last_checkin:, booted:) ⇒ void

This method returns an undefined value.

Writes stats for a worker slot into shared memory.

Parameters:

  • index (Integer) —

    slot index to write into; also written into the slot itself

  • pid (Integer) —

    worker process ID

  • phase (Integer) —

    cluster phase this worker was forked at

  • requests (Integer) —

    total requests handled by this worker

  • backlog (Integer) —

    current queue depth

  • busy_threads (Integer) —

    worker threads currently processing requests

  • thread_capacity (Integer) —

    worker threads configured for this worker

  • started_at (Float) —

    process start time as a Unix timestamp

  • last_checkin (Float) —

    time of last stats write as a Unix timestamp

  • booted (Boolean) —

    whether the worker has finished starting

  • pid: (Integer)
  • phase: (Integer)
  • requests: (Integer)
  • backlog: (Integer)
  • busy_threads: (Integer)
  • thread_capacity: (Integer)
  • started_at: (Float)
  • last_checkin: (Float)
  • booted: (Boolean) 


56
57
58
59
 
# File 'lib/raptor/stats.rb', line 56

def write(index, pid:, phase:, requests:, backlog:, busy_threads:, thread_capacity:, started_at:, last_checkin:, booted:)
  data = [pid, index, phase, requests, backlog, busy_threads, thread_capacity, started_at, last_checkin, booted ? 1 : 0].pack(SLOT_FORMAT)
  @mmap[index * SLOT_SIZE, SLOT_SIZE] = data
end