puma-status-forked 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a084f07e47e934496b5b8fdd8a251166fbffdb9fdbeefc53a420cf49d9753bb5
+  data.tar.gz: a4cfb6c706590a8e25d021c5389d9d3199ca78224ad0167bc58ec85204dbe3c8
+SHA512:
+  metadata.gz: 00e4d9eb55b42d3c943c0060433088fd6460d24d149200862b927a7089da5c99b23d7e530eac27797a2ac1fbedaa50a64d69dc9ba1fcef1b798301e9c2785037
+  data.tar.gz: 910eb9778e282a78b47c833ea761adc7ec3a82e08a7139288ced5a56d2ac193ddfd1595dfc11157ec175343a433034492b8bd94dbd19d16692a7a65f36396c39

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [year] [fullname]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/bin/puma-status

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'puma-status'
+
+run

data/lib/core.rb

@@ -0,0 +1,110 @@
+require 'yaml'
+require 'json'
+require 'net_x/http_unix'
+require 'openssl'
+require 'time'
+require 'open3'
+require_relative 'stats'
+
+def get_stats(state_file_path)
+  puma_state = YAML.load_file(state_file_path)
+
+  uri = URI.parse(puma_state["control_url"])
+
+  address = if uri.scheme =~ /unix/i
+              [uri.scheme, '://', uri.host, uri.path].join
+            else
+              [uri.host, uri.path].join
+            end
+
+  client = NetX::HTTPUnix.new(address, uri.port)
+
+  if uri.scheme =~ /ssl/i
+    client.use_ssl = true
+    client.verify_mode = OpenSSL::SSL::VERIFY_NONE if ENV['SSL_NO_VERIFY'] == '1'
+  end
+
+  req = Net::HTTP::Get.new("/stats?token=#{puma_state["control_auth_token"]}")
+  resp = client.request(req)
+  raw_stats = JSON.parse(resp.body)
+  debug raw_stats
+  stats = Stats.new(raw_stats)
+
+  hydrate_stats(stats, puma_state, state_file_path)
+end
+
+def get_memory_from_top(raw_memory)
+  case raw_memory[-1].downcase
+  when 'g'
+    (raw_memory[0...-1].to_f*1024).to_i
+  when 'm'
+    raw_memory[0...-1].to_i
+  else
+    raw_memory.to_i/1024
+  end
+end
+
+PID_COLUMN = 0
+MEM_COLUMN = 5
+CPU_COLUMN = 8
+OPEN3_STDOUT = 1
+
+def get_top_stats(pids)
+  pids.each_slice(19).inject({}) do |res, pids19|
+    top_result = Open3.popen3({ 'LC_ALL' => 'C' }, "top -b -n 1 -p #{pids19.map(&:to_i).join(',')}")[OPEN3_STDOUT].read
+    top_result.split("\n").last(pids19.length).map { |row| r = row.split(' '); [r[PID_COLUMN].to_i, get_memory_from_top(r[MEM_COLUMN]), r[CPU_COLUMN].to_f] }
+      .inject(res) { |hash, row| hash[row[0]] = { mem: row[1], pcpu: row[2] }; hash }
+    res
+  end
+end
+
+def hydrate_stats(stats, puma_state, state_file_path)
+  stats.pid = puma_state['pid']
+  stats.state_file_path = state_file_path
+
+  workers_pids = stats.workers.map(&:pid)
+
+  top_stats = get_top_stats(workers_pids)
+
+  stats.tap do |s|
+    stats.workers.map do |wstats|
+      wstats.mem = top_stats.dig(wstats.pid, :mem) || 0
+      wstats.pcpu = top_stats.dig(wstats.pid, :pcpu) || 0
+      wstats.killed = !top_stats.key?(wstats.pid) || (wstats.mem <=0 && wstats.pcpu <= 0)
+    end
+  end
+end
+
+def format_stats(stats)
+  master_line = "#{stats.pid} (#{stats.state_file_path})"
+  master_line += " Version: #{stats.version} |" if stats.version
+  master_line += " Uptime: #{seconds_to_human(stats.uptime)}"
+  master_line += " | Phase: #{stats.phase}" if stats.phase
+
+  if stats.booting?
+    master_line += " #{yellow("booting")}"
+  else
+    master_line += " | Load: #{color(75, 50, stats.load, asciiThreadLoad(stats.running_threads, stats.spawned_threads, stats.max_threads))}"
+    master_line += " | Req: #{stats.requests_count}" if stats.requests_count
+  end
+
+  output = [master_line] + stats.workers.map do |wstats|
+    worker_line = " └ #{wstats.pid.to_s.rjust(5, ' ')} CPU: #{color(75, 50, wstats.pcpu, wstats.pcpu.to_s.rjust(5, ' '))}% Mem: #{color(1000, 750, wstats.mem, wstats.mem.to_s.rjust(4, ' '))} MB Uptime: #{seconds_to_human(wstats.uptime)}"
+
+    if wstats.booting?
+      worker_line += " #{yellow("booting")}"
+    elsif wstats.killed?
+      worker_line += " #{red("killed")}"
+    else
+      worker_line += " | Load: #{color(75, 50, wstats.load, asciiThreadLoad(wstats.running_threads, wstats.spawned_threads, wstats.max_threads))}"
+      worker_line += " | Phase: #{red(wstats.phase)}" if wstats.phase != stats.phase
+      worker_line += " | Req: #{wstats.requests_count}" if wstats.requests_count
+      worker_line += " Queue: #{red(wstats.backlog.to_s)}" if wstats.backlog > 0
+      worker_line += " Last checkin: #{red(wstats.last_checkin)}" if wstats.last_checkin >= 10
+    end
+
+    worker_line
+  end
+
+  output.join("\n")
+end

data/lib/helpers.rb

@@ -0,0 +1,64 @@
+require 'rainbow'
+
+def debug(str)
+  puts str if ENV.key?('DEBUG')
+end
+
+def yellow(str)
+  rainbow(str, :yellow)
+end
+
+def red(str)
+  rainbow(str, :red)
+end
+
+def rainbow(str, color_name)
+  return str if ENV.key?('NO_COLOR')
+  Rainbow(str.to_s).send(color_name)
+end
+
+def color(critical, warn, value, str = nil)
+  str = value unless str
+  color_level = if value >= critical
+            :red
+          elsif value < critical && value >= warn
+            :yellow
+          else
+            :green
+          end
+  rainbow(str, color_level)
+end
+
+def asciiThreadLoad(running, spawned, total)
+  full = "█"
+  half= "░"
+  empty = " "
+
+  full_count = running
+  half_count = [spawned - running, 0].max
+  empty_count = total - half_count - full_count
+
+  "#{running}[#{full*full_count}#{half*half_count}#{empty*empty_count}]#{total}"
+end
+
+def seconds_to_human(seconds)
+
+  #=>  0m 0s
+  #=> 59m59s
+  #=>  1h 0m
+  #=> 23h59m
+  #=>  1d 0h
+  #=>    24d
+
+  if seconds <= 0
+    "--m--s"
+  elsif seconds < 60*60
+    "#{(seconds/60).to_s.rjust(2, ' ')}m#{(seconds%60).to_s.rjust(2, ' ')}s"
+  elsif seconds >= 60*60*1 && seconds < 60*60*24
+    "#{(seconds/(60*60*1)).to_s.rjust(2, ' ')}h#{((seconds%(60*60*1))/60).to_s.rjust(2, ' ')}m"
+  elsif seconds > 60*60*24 && seconds < 60*60*24*10
+    "#{(seconds/(60*60*24)).to_s.rjust(2, ' ')}d#{((seconds%(60*60*24))/(60*60*1)).to_s.rjust(2, ' ')}h"
+  else
+    "#{seconds/(60*60*24)}d".rjust(6, ' ')
+  end
+end

data/lib/puma-status-forked.rb

@@ -0,0 +1,48 @@
+require_relative './helpers'
+require_relative './core.rb'
+require 'parallel'
+
+def run
+  debug "puma-status"
+
+  if ARGV.count < 1
+    puts "Call with:"
+    puts "\tpuma-status path/to/puma.state"
+    exit -1
+  end
+
+  errors = []
+  
+  outputs = Parallel.map(ARGV, in_threads: ARGV.count) do |state_file_path|
+    begin
+      debug "State file: #{state_file_path}"
+      format_stats(get_stats(state_file_path))
+    rescue Errno::ENOENT => e
+      if e.message =~ /#{state_file_path}/
+        errors << "#{yellow(state_file_path)} doesn't exist"
+      elsif e.message =~ /connect\(2\) for [^\/]/
+        errors << "#{yellow("Relative Unix socket")}: the Unix socket of the control app has a relative path. Please, ensure you are running from the same folder as puma."
+      else
+        errors << "#{red(state_file_path)} an unhandled error occured: #{e.inspect}"
+      end
+      nil
+    rescue Errno::EISDIR => e
+      if e.message =~ /#{state_file_path}/
+        errors << "#{yellow(state_file_path)} isn't a state file"
+      else
+        errors << "#{red(state_file_path)} an unhandled error occured: #{e.inspect}"
+      end
+      nil
+    rescue => e
+      errors << "#{red(state_file_path)} an unhandled error occured: #{e.inspect}"
+      nil
+    end
+  end
+
+  outputs.compact.each { |output| puts output }
+
+  if errors.any?
+    puts ""
+    errors.each { |error| puts error }
+  end
+end

data/lib/stats.rb

@@ -0,0 +1,163 @@
+class Stats
+
+  class Worker
+    def initialize(wstats)
+      @wstats = wstats
+    end
+
+    def pid
+      @wstats['pid']
+    end
+
+    def killed=(killed)
+      @wstats['killed'] = killed
+    end
+
+    def killed?
+      !!@wstats['killed']
+    end
+
+    def mem=(mem)
+      @wstats['mem'] = mem
+    end
+
+    def mem
+      @wstats['mem']
+    end
+
+    def pcpu=(pcpu)
+      @wstats['pcpu'] = pcpu
+    end
+
+    def pcpu
+      @wstats['pcpu']
+    end
+
+    def booting?
+      @wstats.key?('last_status') && @wstats['last_status'].empty?
+    end
+
+    def running
+      @wstats.dig('last_status', 'running') || @wstats['running'] || 0
+    end
+    alias :total_threads :running
+    alias :spawned_threads :running
+
+    def max_threads
+      @wstats.dig('last_status', 'max_threads') || @wstats['max_threads'] || 0
+    end
+    alias :total_threads :max_threads
+
+    def pool_capacity
+      @wstats.dig('last_status', 'pool_capacity') || @wstats['pool_capacity'] || 0
+    end
+
+    def running_threads
+      max_threads - pool_capacity
+    end
+
+    def phase
+      @wstats['phase']
+    end
+
+    def load
+      running_threads/total_threads.to_f*100
+    end
+
+    def uptime
+      return 0 unless @wstats.key?('started_at')
+      (Time.now - Time.parse(@wstats['started_at'])).to_i
+    end
+
+    def requests_count
+      @wstats.dig('last_status', 'requests_count') || @wstats['requests_count']
+    end
+
+    def backlog
+      @wstats.dig('last_status', 'backlog') || 0
+    end
+
+    def last_checkin
+      (Time.now - Time.parse(@wstats['last_checkin'])).round
+    rescue
+      0
+    end
+  end
+
+  def initialize(stats)
+    @stats = stats
+  end
+
+  def workers
+    @workers ||= (@stats['worker_status'] || [@stats]).map { |wstats| Worker.new(wstats) }
+  end
+
+  def pid=(pid)
+    @stats['pid'] = pid
+  end
+
+  def pid
+    @stats['pid']
+  end
+
+  def state_file_path=(state_file_path)
+    @stats['state_file_path'] = state_file_path
+  end
+
+  def state_file_path
+    @stats['state_file_path']
+  end
+
+  def uptime
+    return 0 unless @stats.key?('started_at')
+    (Time.now - Time.parse(@stats['started_at'])).to_i
+  end
+
+  def booting?
+    workers.all?(&:booting?)
+  end
+
+  def total_threads
+    workers.reduce(0) { |total, wstats| total + wstats.max_threads }
+  end
+
+  def running_threads
+    workers.reduce(0) { |total, wstats| total + wstats.running_threads }
+  end
+
+  def spawned_threads
+    workers.reduce(0) { |total, wstats| total + wstats.spawned_threads }
+  end
+
+  def max_threads
+    workers.reduce(0) { |total, wstats| total + wstats.max_threads }
+  end
+
+  def requests_count
+    workers_with_requests_count = workers.select(&:requests_count)
+    return if workers_with_requests_count.none?
+    workers_with_requests_count.reduce(0) { |total, wstats| total + wstats.requests_count }
+  end
+
+  def running
+    @stats['running'] || 0
+  end
+
+  def pool_capacity
+    @stats['pool_capacity'] || 0
+  end
+
+  def phase
+    @stats['phase']
+  end
+
+  def load
+    running_threads/total_threads.to_f*100
+  end
+
+  def version
+    return nil unless @stats.key?('versions')
+
+    "#{@stats['versions']['puma']}/#{@stats['versions']['ruby']['engine']}#{@stats['versions']['ruby']['version']}p#{@stats['versions']['ruby']['patchlevel']}"
+  end
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: puma-status-forked
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Yoann Lecuyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.1
+- !ruby/object:Gem::Dependency
+  name: net_http_unix
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: parallel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: climate_control
+  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: timecop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 
+email: 
+executables:
+- puma-status
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- bin/puma-status
+- lib/core.rb
+- lib/helpers.rb
+- lib/puma-status-forked.rb
+- lib/stats.rb
+homepage: https://github.com/robin249/puma-status
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.6
+signing_key: 
+specification_version: 4
+summary: Command-line tool for puma to display information about running request/process.
+  We have replaced the colorize gem by rainbow gem due to GPL license issue.
+test_files: []