puma-log_stats-codeur 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2449156394b5c86c2bee695565450e4c49a0b2bb87b15d3e7cb03e21ac47b322
-  data.tar.gz: 91887bd1d2f23c594889504063268d5dfeadcebd2a1539bbd4300aec14625eb4
+  metadata.gz: 7dccacaaaed068382710999238bf1563335653ba81ac0afe70373eb53fc6c4ec
+  data.tar.gz: 3183d3640deb3b060873061e10087c06e429aa0be8d60ba0b8924adf3c379890
 SHA512:
-  metadata.gz: 3084f6e89321b110e7bec943ff66435dbc3446a84257929e937a073bc80e8ca21209661050dbc9c4b2bf7a6d3f14dd291b31221eeafe937b8e737974c1bda630
-  data.tar.gz: 6b6f9f8f4fe2925f4dccdd89b503516d350932e0875fb3d50e42eb2c21f4b8f5ad10c53108564fe8ec721a47a9d1add5bc464076ac4affc8a873f08692002b59
+  metadata.gz: 060ed7df03b49ccfb212d4d18f117bff2f4fc054fc6dcece408d11efbd8bbacf4f958c9e7e46251fb3da1703318afb60df7bad77723038677febf1197cc5d7bf
+  data.tar.gz: fbf036c802861ff041d4a3c777af0767b6c8e0d73cebb489c2049dea6183036f16bd6964cd8b8c54312a244502454271ead82259e2cb4abcee93f82811919a6c

data/README.md

@@ -1,6 +1,6 @@
 # PumaLogStats
 
-Puma plugin to log server stats whenever the number of concurrent requests exceeds a configured threshold.
+Puma plugin to log server stats to puma.log. It logs changes only and can raise Sentry issues when a threshold is reached.
 
 ## Installation
 
@@ -26,7 +26,10 @@ This plugin is loaded using Puma's plugin API. To enable, add a `plugin :log_sta
 # config/puma.rb
 
 plugin :log_stats
-LogStats.threshold = 2
+# LogStats.interval = 10
+# LogStats.notify_change_with = :sentry # can be a Proc
+# LogStats.warning_threshold = 0.7
+# LogStats.critical_threshold = 0.85
 ```
 
 ## Development

data/lib/puma/log_stats/version.rb

@@ -2,6 +2,6 @@
 
 module Puma
   module LogStats
-    VERSION = "0.1.1"
+    VERSION = "0.1.3"
   end
 end

data/lib/puma/log_stats.rb

@@ -1,3 +1 @@
 # frozen_string_literal: true
-
-# require "puma/log_stats/version"

data/lib/puma/plugin/log_stats.rb

@@ -2,237 +2,140 @@
 
 require "puma/plugin"
 
-module LogStats
-  class << self
-    # Interval between logging attempts in seconds.
-    attr_accessor :interval
-    LogStats.interval = 10
+module Puma
+  module LogStats
+    class << self
+      # Interval between logging attempts in seconds.
+      attr_accessor :interval
+      LogStats.interval = 10
 
-    attr_accessor :alarm_on_sentry
-    LogStats.alarm_on_sentry = true
+      attr_accessor :notify_change_with
+      LogStats.notify_change_with = :sentry
 
-    attr_accessor :alarm_notification_interval
-    LogStats.alarm_notification_interval = 60
+      attr_accessor :warning_threshold
+      LogStats.warning_threshold = 0.7
 
-    attr_accessor :warning_threshold
-    LogStats.warning_threshold = 0.7
+      attr_accessor :critical_threshold
+      LogStats.critical_threshold = 0.85
+    end
 
-    attr_accessor :critical_threshold
-    LogStats.critical_threshold = 0.85
-  end
+    def start(launcher)
+      @launcher = launcher
+      launcher.events.register(:state) do |state|
+        if %i[halt restart stop].include?(state)
+          @running = false
+        end
+      end
 
-  def start(launcher)
-    @launcher = launcher
-    launcher.events.register(:state) do |state|
-      if %i[halt restart stop].include?(state)
-        @running = false
+      in_background do
+        @running = true
+        @load_level = :normal
+        while @running
+          sleep LogStats.interval
+          @previous_status_message = @status_message
+          @stats = Puma.stats_hash
+          @status_message = status_message
+          log(@status_message) if @previous_status_message != @status_message
+          check_alarms
+        end
       end
     end
 
-    in_background do
-      @running = true
-      @load_level = :normal
-      while @running
-        sleep LogStats.interval
-        @stats = Puma.stats_hash
-        log(status)
-        check_alarms
-      end
+    def check_alarms
+      threshold_reached(:critical, LogStats.critical_threshold) ||
+        threshold_reached(:warning, LogStats.warning_threshold) ||
+        normal_load
     end
-  end
 
-  def check_alarms
-    threshold_reached(:critical, LogStats.critical_threshold) ||
-      threshold_reached(:warning, LogStats.warning_threshold) ||
-      normal_load
-  end
+    def threshold_reached(level, threshold)
+      return false if threads_load < threshold
 
-  def threshold_reached(level, threshold)
-    return false if threads_load < threshold
+      change_level(level, "Puma threads load is greater than #{threshold * 100}% (#{max_threads - pool_capacity}/#{max_threads})")
+      true
+    end
 
-    notify_alarm("#{level.to_s.upcase}: Puma threads load is more than #{threshold * 100}% (#{max_threads - pool_capacity}/#{max_threads})")
-    @load_level = level if @load_level != level
-    true
-  end
+    def normal_load
+      change_level(:normal, "Puma threads load is back to normal values")
+    end
 
-  def normal_load
-    return if @load_level == :normal
+    def change_level(level, message)
+      return if @load_level == level
 
-    log("INFO: Puma threads load is back to normal values")
-    @load_level = :normal
-  end
+      log("#{level.to_s.upcase}: #{message}")
+      notify(level, message)
+      @load_level = level
+    end
 
-  def notify_alarm(message)
-    if @notified_at.nil? || (Time.now - @notified_at) < LogStats.alarm_notification_interval
-      log(message)
-      Sentry.capture_message(message) if LogStats.alarm_on_sentry && defined?(Sentry)
-      @notified_at = Time.now
+    def notify(level, message)
+      if LogStats.notify_change_with == :sentry
+        Sentry.capture_message(message, level: (level == :critical) ? :error : level) if defined?(Sentry) && level != :normal
+      elsif LogStats.notify_change_with.respond_to?(:call)
+        LogStats.notify_change_with.call(level: level, message: message, threads_load: threads_load)
+      end
     end
-  end
 
-  def status
-    if clustered?
-      "cluster: #{booted_workers}/#{workers} workers: #{running}/#{max_threads} threads, #{pool_capacity} available, #{backlog} backlog"
-    else
-      "single: #{running}/#{max_threads} threads, #{pool_capacity} available, #{backlog} backlog"
+    def status_message
+      if clustered?
+        "cluster: #{booted_workers}/#{workers} workers: #{running}/#{max_threads} threads, #{pool_capacity} available, #{backlog} backlog"
+      else
+        "single: #{running}/#{max_threads} threads, #{pool_capacity} available, #{backlog} backlog"
+      end
     end
-  end
 
-  def log(str)
-    @launcher.log_writer.log("[#{Time.now}][puma #{Puma::Const::VERSION}] #{str}")
-  end
+    def log(str)
+      @launcher.log_writer.log("[#{Time.now}][puma #{Puma::Const::VERSION}] #{str}")
+    end
 
-  def threads_load
-    1.0 - pool_capacity.to_f / max_threads.to_f
-  end
+    def threads_load
+      1.0 - pool_capacity.to_f / max_threads.to_f
+    end
 
-  def clustered?
-    @stats.key?(:workers)
-  end
+    def clustered?
+      @stats.key?(:workers)
+    end
 
-  def workers
-    @stats.fetch(:workers, 1)
-  end
+    def workers
+      @stats.fetch(:workers, 1)
+    end
 
-  def booted_workers
-    @stats.fetch(:booted_workers, 1)
-  end
+    def booted_workers
+      @stats.fetch(:booted_workers, 1)
+    end
 
-  def running
-    if clustered?
-      @stats[:worker_status].sum { |s| s[:last_status].fetch(:running, 0) }
-    else
-      @stats.fetch(:running, 0)
+    def running
+      if clustered?
+        @stats[:worker_status].sum { |s| s[:last_status].fetch(:running, 0) }
+      else
+        @stats.fetch(:running, 0)
+      end
     end
-  end
 
-  def backlog
-    if clustered?
-      @stats[:worker_status].sum { |s| s[:last_status].fetch(:backlog, 0) }
-    else
-      @stats.fetch(:backlog, 0)
+    def backlog
+      if clustered?
+        @stats[:worker_status].sum { |s| s[:last_status].fetch(:backlog, 0) }
+      else
+        @stats.fetch(:backlog, 0)
+      end
     end
-  end
 
-  def pool_capacity
-    if clustered?
-      @stats[:worker_status].sum { |s| s[:last_status].fetch(:pool_capacity, 0) }
-    else
-      @stats.fetch(:pool_capacity, 0)
+    def pool_capacity
+      if clustered?
+        @stats[:worker_status].sum { |s| s[:last_status].fetch(:pool_capacity, 0) }
+      else
+        @stats.fetch(:pool_capacity, 0)
+      end
     end
-  end
 
-  def max_threads
-    if clustered?
-      @stats[:worker_status].sum { |s| s[:last_status].fetch(:max_threads, 0) }
-    else
-      @stats.fetch(:max_threads, 0)
+    def max_threads
+      if clustered?
+        @stats[:worker_status].sum { |s| s[:last_status].fetch(:max_threads, 0) }
+      else
+        @stats.fetch(:max_threads, 0)
+      end
     end
   end
 end
 
 Puma::Plugin.create do
-  include LogStats
+  include Puma::LogStats
 end
-
-# require "puma"
-# require "puma/plugin"
-# require "json"
-
-# # Puma plugin to log server stats whenever the number of
-# # concurrent requests exceeds a configured threshold.
-# module LogStats
-#   STAT_METHODS = %i[backlog running pool_capacity max_threads requests_count].freeze
-
-#   class << self
-#     # Minimum concurrent requests per process that will trigger logging server
-#     # stats, or nil to disable logging.
-#     # Default is the max number of threads in the server's thread pool.
-#     # If this attribute is a Proc, it will be re-evaluated each interval.
-#     attr_accessor :threshold
-#     LogStats.threshold = :max
-
-#     # Interval between logging attempts in seconds.
-#     attr_accessor :interval
-#     LogStats.interval = 1
-
-#     # Proc to filter backtraces.
-#     attr_accessor :backtrace_filter
-#     LogStats.backtrace_filter = ->(bt) { bt }
-#   end
-
-#   Puma::Plugin.create do
-#     attr_reader :launcher
-
-#     def start(launcher)
-#       @launcher = launcher
-#       launcher.events.register(:state) do |state|
-#         @state = state
-#         stats_logger_thread if state == :running
-#       end
-
-#       in_background { start }
-#     end
-
-#     private
-
-#     def stats_logger_thread
-#       Thread.new do
-#         if Thread.current.respond_to?(:name=)
-#           Thread.current.name = "puma stats logger"
-#         end
-#         start while @state == :running
-#       end
-#     end
-
-#     def start
-#       sleep LogStats.interval
-#       return unless server
-
-#       if should_log?
-#         stats = server_stats
-#         stats[:threads] = thread_backtraces
-#         stats[:gc] = GC.stat
-#         log stats.to_json
-#       end
-#     rescue => e
-#       log "LogStats failed: #{e}\n  #{e.backtrace.join("\n    ")}"
-#     end
-
-#     def log(str)
-#       launcher.log_writer.log str
-#     end
-
-#     # Save reference to Server object from the thread-local key.
-#     def server
-#       @server ||= Thread.list.map { |t| t[Puma::Server::ThreadLocalKey] }.compact.first
-#     end
-
-#     def server_stats
-#       STAT_METHODS.select(&server.method(:respond_to?))
-#         .map { |name| [name, server.send(name) || 0] }.to_h
-#     end
-
-#     # True if current server load meets configured threshold.
-#     def should_log?
-#       threshold = LogStats.threshold
-#       threshold = threshold.call if threshold.is_a?(Proc)
-#       threshold = server.max_threads if threshold == :max
-#       threshold && (server.max_threads - server.pool_capacity) >= threshold
-#     end
-
-#     def thread_backtraces
-#       worker_threads.map do |t|
-#         name = t.respond_to?(:name) ? t.name : thread.object_id.to_s(36)
-#         [name, LogStats.backtrace_filter.call(t.backtrace)]
-#       end.sort.to_h
-#     end
-
-#     # List all non-idle worker threads in the thread pool.
-#     def worker_threads
-#       server.instance_variable_get(:@thread_pool)
-#         .instance_variable_get(:@workers)
-#         .reject { |t| t.backtrace.first.match?(/thread_pool\.rb.*sleep/) }
-#     end
-#   end
-# end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: puma-log_stats-codeur
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Will Jordan