neetodeploy-autoscale 2.1.5 → 2.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9c625c0a7ce10076e313d0c9e7055e0c96cb442e3406d1ea9713301d5c3e59b
-  data.tar.gz: 77ae413d23b920136d168877c6739141de5088b6ecbe3e28f58ea32ed52ca1ff
+  metadata.gz: 3b6d47e127492bf2a818f87ad72b9a57c70bb1c4d124b620a495a73d6a814779
+  data.tar.gz: 0d211f2a58c654f5e451dcf58c43cac205b0210855afbc4f43ef8db6cb55f66a
 SHA512:
-  metadata.gz: 2282c9b7980edb2e17413115c6c06759e3d4a818c0d615f729e04c409f4ea3fb1fd7c1f41e8db1c6fd32a1e27fe30d862eb59e9499666a9dceb604aeb4ece96b
-  data.tar.gz: ff3d40bc1b40f349b7fc7470cf33f6d7da7daa5c860f556f3f1df4871463956d7341a02c74a58bb5766134f142d64a88bf113c7c1d5bae64094af9242cd00ebb
+  metadata.gz: c6647e9faad55fb5e79b2321cb848ebb34d65ec5fae65ee99f0f7cfabf5b018caecb20a38811dd07d4b91ee0acb770ade98c5d46be674fe360d888a5082f989c
+  data.tar.gz: 1fd46a9ae0725de810b3109a5011ad7cebea3c851f14168773d8ce3a205cb22f1756ec0f88440badbd84f5f4f3c107b1d5f067494b6446cfda44adbad77f08c9

data/lib/neetodeploy/autoscale/config.rb

@@ -2,35 +2,30 @@ module Neetodeploy
   class Config
     include Singleton
 
-    DEFAULT_METRICS_URL = "http://nd-queue-time-exporter-web-deployment:3000/metrics"
-    DEFAULT_BATCH_URL = "http://nd-queue-time-exporter-web-deployment:3000/metrics/batch"
-    DEFAULT_AUTH_TOKEN = "K0An3O3MSyEEMTCnRd1IHgGjdGQkzy"
-    DEFAULT_REPORT_INTERVAL = 10
-
-    attr_reader :app_name, :metrics_server_url, :metrics_server_batch_url, 
-                :metrics_server_auth_token, :report_interval_seconds
+    attr_accessor :disable_auto_scale_gem, :disable_sidekiq_metrics, :app_name, :process_type,
+                  :metrics_server_url, :metrics_server_auth_token, :report_interval_seconds, :use_puma_queue_size
 
     def initialize
+      @disable_auto_scale_gem = ENV["DISABLE_NEETO_DEPLOY_AUTOSCALE"]
+      @disable_sidekiq_metrics = ENV["DISABLE_NEETO_DEPLOY_SIDEKIQ_METRICS"]
       @app_name = ENV["NEETODEPLOY_APP_NAME"]
-      @metrics_server_url = DEFAULT_METRICS_URL
-      @metrics_server_batch_url = DEFAULT_BATCH_URL
-      @metrics_server_auth_token = DEFAULT_AUTH_TOKEN
-      @report_interval_seconds = (ENV["NEETODEPLOY_REPORT_INTERVAL_SECONDS"]&.to_i || DEFAULT_REPORT_INTERVAL)
-      @gem_disabled = ENV["DISABLE_NEETO_DEPLOY_AUTOSCALE"] == "true"
-      @sidekiq_metrics_disabled = ENV["DISABLE_NEETO_DEPLOY_SIDEKIQ_METRICS"] == "true"
-      @batch_processing_enabled = ENV["NEETODEPLOY_BATCH_PROCESSING_ENABLED"] == "true"
+      @process_type = ENV["NEETODEPLOY_PROCESS_TYPE"] || "worker"
+      @metrics_server_url = "http://nd-queue-time-exporter-web-deployment:3000/metrics"
+      @metrics_server_auth_token = "K0An3O3MSyEEMTCnRd1IHgGjdGQkzy"
+      @report_interval_seconds = 10
+      @use_puma_queue_size = ENV["NEETODEPLOY_USE_PUMA_QUEUE_SIZE"] == "true"
     end
 
     def gem_disabled?
-      @gem_disabled
+      disable_auto_scale_gem == "true"
     end
 
     def sidekiq_metrics_disabled?
-      @sidekiq_metrics_disabled
+      disable_sidekiq_metrics == "true"
     end
 
-    def batch_processing_enabled?
-      @batch_processing_enabled
+    def use_puma_queue_size?
+      use_puma_queue_size == true
     end
   end
 end

data/lib/neetodeploy/autoscale/rails/metrics.rb

@@ -1,69 +1,28 @@
 # frozen_string_literal: true
 
 require "neetodeploy/autoscale/config"
-require "neetodeploy/autoscale/logger"
 
 module Neetodeploy
   module Rails
     class Metrics
       def initialize(env, config = Config.instance)
         @config = config
-        @env = env
-        @request_start_header_raw = env["HTTP_X_REQUEST_START"]
-        @request_start_header = @request_start_header_raw.to_i
+        @request_start_header = env["HTTP_X_REQUEST_START"].to_i
         @network_time = env["puma.request_body_wait"].to_i
-        
-        # Debug: Log all HTTP headers to help diagnose (only for non-health-check requests)
-        if (@request_start_header_raw.nil? || @request_start_header_raw.empty?) && !health_check_request?(env)
-          # Get all HTTP_* headers (these are the request headers)
-          http_headers = env.keys.grep(/^HTTP_/)
-          
-          if http_headers.any?
-            NeetoDeploy::Logger.logger.debug("All HTTP headers found: #{http_headers.sort.join(', ')}")
-          else
-            NeetoDeploy::Logger.logger.debug("No HTTP headers found in env. Available env keys: #{env.keys.grep(/^HTTP|^REQUEST|^SERVER/).sort.join(', ')}")
-          end
-          
-          # Also check for X-Request-Start with different casing
-          x_request_variants = env.select { |k, _| k.to_s.upcase.include?("REQUEST_START") || k.to_s.upcase.include?("X_REQUEST") }
-          if x_request_variants.any?
-            NeetoDeploy::Logger.logger.debug("Found X-Request-Start variants: #{x_request_variants.keys.join(', ')}")
-          end
-        end
       end
 
       def ignore?
-        @config.gem_disabled? || health_check_request?(@env)
-      end
-
-      def health_check_request?(env = @env)
-        # Ignore health check endpoints that don't go through Traefik
-        # These typically come from Kubernetes liveness/readiness probes
-        path = env["PATH_INFO"] || env["REQUEST_PATH"] || ""
-        path.match?(%r{/health_check|/health|/up|/ready|/live})
+        @config.gem_disabled?
       end
 
       def queue_time
-        # Debug: Log if header is missing or invalid
-        if @request_start_header_raw.nil? || @request_start_header_raw.empty?
-          NeetoDeploy::Logger.logger.debug("X-Request-Start header missing or empty")
-          return nil
-        end
-
-        return nil if @request_start_header.zero?
+        return if @request_start_header.zero?
 
         time_now = Time.now.to_f * 1000
 
         queue_time = (time_now - @request_start_header).round
         queue_time -= @network_time
 
-        # Log both values for debugging
-        NeetoDeploy::Logger.logger.debug(
-          "Queue time calculation: X-Request-Start=#{@request_start_header_raw} (#{@request_start_header}ms), " \
-          "puma.request_body_wait=#{@network_time}ms, time_now=#{time_now.round}ms, " \
-          "calculated_queue_time=#{queue_time}ms"
-        )
-
         queue_time.positive? ? queue_time : nil
       end
     end

data/lib/neetodeploy/autoscale/rails/metrics_collector.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "singleton"
+require "json"
 require "neetodeploy/autoscale/reporter"
 require "neetodeploy/autoscale/logger"
 require "neetodeploy/autoscale/config"
@@ -12,17 +13,16 @@ module Neetodeploy
       include Singleton
       include NeetoDeploy::Logger
 
-      PERCENTILES = { p90: 0.90, p95: 0.95, p99: 0.99 }.freeze
-      RESTART_DELAY = 5
-
       def self.start
         instance.start! unless instance.running?
       end
 
       def start!
-        logger.info("Starting background worker to collect metrics")
+        config = Config.instance
+        mode = config.use_puma_queue_size? ? "Puma queue size" : "response time"
+        logger.info("Starting background worker to collect #{mode} metrics")
         @pid = Process.pid
-        start_collector_thread
+        start_thread_with_collector_loop
       end
 
       def stop!
@@ -32,28 +32,30 @@ module Neetodeploy
       end
 
       def running?
-        @pid == Process.pid && @thread&.alive?
+        @pid == Process.pid and @thread&.alive?
       end
 
-      private
-
-      def start_collector_thread(config = Config.instance)
+      def start_thread_with_collector_loop(config = Config.instance)
         @thread = Thread.new do
+          metrics_store = MetricsStore.instance unless config.use_puma_queue_size?
           loop do
-            begin
-              metrics_store = MetricsStore.instance
-              collect_and_report_loop(metrics_store, config)
-            rescue StandardError => e
-              handle_collection_error(e, config)
+            if config.use_puma_queue_size?
+              run_puma_metrics_collection(config)
+            else
+              run_queue_time_collection(metrics_store, config)
             end
+            multiplier = 1 - (rand / 4)
+            sleep config.report_interval_seconds * multiplier
+          end
+        rescue StandardError => e
+          logger.error("Rails metrics collector thread terminated with error: #{e.message}")
+          logger.error(e.backtrace.join("\n")) if e.backtrace
+        ensure
+          if @pid == Process.pid && !@thread.nil?
+            logger.info("Restarting Rails metrics collector thread")
+            sleep(5)
+            start_thread_with_collector_loop
           end
-        end
-      end
-
-      def collect_and_report_loop(metrics_store, config)
-        loop do
-          run_queue_time_collection(metrics_store, config)
-          sleep(config.report_interval_seconds)
         end
       end
 
@@ -63,71 +65,49 @@ module Neetodeploy
         data = metrics_store.flush
         return if data.empty?
 
-        if config.batch_processing_enabled?
-          report_batch_metrics(data, config)
-        else
-          report_average_metric(data, config)
-        end
+        average_queue_time = data.sum / data.size
+        Reporter.new(average_queue_time, "queue_time", "web").report
       end
 
-      def report_batch_metrics(data, config)
-        sorted_data = data.sort
-        size = sorted_data.size
-
-        # Calculate percentiles
-        p90 = percentile_value(sorted_data, size, 0.90)
-        p95 = percentile_value(sorted_data, size, 0.95)
-        p99 = percentile_value(sorted_data, size, 0.99)
-        avg = data.sum / data.size
-
-        min_val = sorted_data.first
-        max_val = sorted_data.last
-        logger.debug("Calculated metrics from #{size} samples: min=#{min_val}, max=#{max_val}, avg=#{avg}, p90=#{p90}, p95=#{p95}, p99=#{p99}")
+      def run_puma_metrics_collection(config)
+        return unless puma_available?
+        return if config.gem_disabled?
 
-        if size <= 10
-          logger.debug("All values in this batch: #{sorted_data.join(', ')}")
-        elsif size <= 50
-          logger.debug("Sample values: first 5=#{sorted_data[0..4].join(', ')}, last 5=#{sorted_data[-5..-1].join(', ')}")
-        end
+        begin
+          queue_size = get_puma_queue_size
+          return if queue_size.nil?
 
-        if max_val > 500 && p95 < max_val * 0.5
-          logger.warn("High queue time detected (#{max_val}ms) but P95 is much lower (#{p95}ms). Sample size: #{size}. This suggests high values are being diluted by many low values.")
+          Reporter.new(queue_size, "puma_queue_size", "web").report
+        rescue StandardError => e
+          logger.error("Error collecting Puma queue size metrics: #{e.message}")
         end
-
-        metrics = [
-          { metric_name: "queue_time_p90", metric_value: p90 },
-          { metric_name: "queue_time_p95", metric_value: p95 },
-          { metric_name: "queue_time_p99", metric_value: p99 },
-          { metric_name: "queue_time_max", metric_value: max_val },
-          { metric_name: "queue_time", metric_value: avg }
-        ]
-
-        Reporter.report_batch(metrics, "web", nil, config)
       end
 
-      def report_average_metric(data, config)
-        average_queue_time = data.sum.fdiv(data.size).round
-        Reporter.new(average_queue_time, "queue_time", "web", nil, config).report
-      end
+      private
 
-      def percentile_value(sorted_data, size, percentile)
-        # Use nearest rank method: index = ceil(size * percentile) - 1
-        # For small samples, this ensures we get a valid index
-        index = [(size * percentile).ceil - 1, 0].max
-        # Clamp index to valid range
-        index = [index, size - 1].min
-        sorted_data[index]
-      end
+        def puma_available?
+          defined?(::Puma) && ::Puma.respond_to?(:stats)
+        end
 
-      def handle_collection_error(error, config)
-        logger.error("Rails metrics collector thread error: #{error.message}")
-        logger.error(error.backtrace.join("\n")) if error.backtrace
+        def get_puma_queue_size
+          stats_json = ::Puma.stats
+          return nil if stats_json.nil? || stats_json.empty?
 
-        should_restart = @pid == Process.pid && @thread
-        logger.info("Restarting Rails metrics collector thread") if should_restart
+          stats = JSON.parse(stats_json)
 
-        sleep(RESTART_DELAY) if should_restart
-      end
+          # For clustered mode (multiple workers)
+          if stats["worker_status"]
+            # Sum backlog from all workers
+            stats["worker_status"].sum do |worker|
+              worker.dig("last_status", "backlog") || 0
+            end
+          # For single mode
+          elsif stats["backlog"]
+            stats["backlog"]
+          else
+            nil
+          end
+        end
     end
   end
 end

data/lib/neetodeploy/autoscale/rails/metrics_store.rb

@@ -1,71 +1,26 @@
 # frozen_string_literal: true
 
 require "singleton"
-require "neetodeploy/autoscale/logger"
 
 module Neetodeploy
   module Rails
     class MetricsStore
       include Singleton
 
-      # Use sliding window: keep last 2 minutes of data (120 seconds)
-      # At 2s reporting interval, this gives us ~60 samples per window
-      # This ensures percentiles work correctly even with low traffic
-      WINDOW_SIZE_SECONDS = 120
-      MAX_SAMPLES = 1000  # Safety limit to prevent memory bloat
-
       attr_reader :metrics
 
       def initialize
-        @metrics = []  # Array of {time: timestamp, value: queue_time}
-        @mutex = Mutex.new
+        @metrics = []
       end
 
       def push(queue_time)
-        @mutex.synchronize do
-          now = Time.now.to_f
-          @metrics << { time: now, value: queue_time }
-          
-          # Remove old data outside window
-          cutoff = now - WINDOW_SIZE_SECONDS
-          @metrics.reject! { |m| m[:time] < cutoff }
-          
-          # Safety limit: keep only most recent samples
-          if @metrics.size > MAX_SAMPLES
-            @metrics = @metrics.last(MAX_SAMPLES)
-          end
-          
-          # Log high queue times to help debug
-          if queue_time > 500
-            NeetoDeploy::Logger.logger.debug("MetricsStore: Pushed high queue_time=#{queue_time}ms (total in window: #{@metrics.size})")
-          end
-        end
-      end
-
-      # Get recent samples from the sliding window (last N seconds)
-      def get_recent(seconds = WINDOW_SIZE_SECONDS)
-        @mutex.synchronize do
-          cutoff = Time.now.to_f - seconds
-          @metrics.select { |m| m[:time] >= cutoff }.map { |m| m[:value] }
-        end
+        @metrics << queue_time
       end
 
-      # Flush: return all values in window, but DON'T clear (sliding window)
-      # This allows high values to persist across multiple reporting cycles
       def flush
-        @mutex.synchronize do
-          # Clean up old data first
-          cutoff = Time.now.to_f - WINDOW_SIZE_SECONDS
-          @metrics.reject! { |m| m[:time] < cutoff }
-          
-          result = @metrics.map { |m| m[:value] }
-          size = result.size
-          max_val = result.max if result.any?
-          NeetoDeploy::Logger.logger.debug("MetricsStore: Reporting from sliding window: #{size} values, max=#{max_val}ms") if result.any?
-          
-          # Return values but keep them in the window for next cycle
-          result
-        end
+        result = @metrics
+        @metrics = []
+        result
       end
     end
   end

data/lib/neetodeploy/autoscale/rails/middleware.rb

@@ -3,6 +3,7 @@
 require "neetodeploy/autoscale/rails/metrics"
 require "neetodeploy/autoscale/rails/metrics_store"
 require "neetodeploy/autoscale/rails/metrics_collector"
+require "neetodeploy/autoscale/config"
 
 module Neetodeploy
   module Rails
@@ -12,13 +13,18 @@ module Neetodeploy
       end
 
       def call(env)
-        metrics = Metrics.new(env)
-        queue_time = metrics.queue_time unless metrics.ignore?
+        config = Config.instance
         MetricsCollector.start
 
-        if queue_time
-          store = MetricsStore.instance
-          store.push queue_time
+        # Only collect queue time per request if using the old response time method
+        unless config.use_puma_queue_size?
+          metrics = Metrics.new(env)
+          queue_time = metrics.queue_time unless metrics.ignore?
+
+          if queue_time
+            store = MetricsStore.instance
+            store.push queue_time
+          end
         end
 
         @app.call(env)

data/lib/neetodeploy/autoscale/reporter.rb

@@ -2,7 +2,6 @@
 
 require "net/http"
 require "time"
-require "json"
 require "neetodeploy/autoscale/config"
 require "neetodeploy/autoscale/logger"
 
@@ -19,100 +18,39 @@ module Neetodeploy
     end
 
     def report
-      url = build_url(common_params)
-      logger.info("Reporting #{@metric_name} for #{@process_type}: #{@metric_value}")
-      post_request(url)
-    end
-
-    def self.report_batch(metrics, process_type, queue_name = nil, config = Config.instance)
-      return if metrics.empty?
+      params = common_params
+      params[:queue_name] = @queue_name if @queue_name
+      url = build_url(params)
+      logger.info("Reporting #{@metric_name} for #{@process_type} dyno: #{@metric_value}")
 
-      payload = build_batch_payload(metrics, process_type, queue_name, config)
-      url = config.metrics_server_batch_url
-      
-      NeetoDeploy::Logger.logger.info("Batch reporting #{metrics.size} metrics for #{process_type}")
-      post_batch_request(url, payload, config)
+      post_request(url)
     end
 
     private
 
-      def common_params
-        {
-          app_name: @config.app_name,
-          queue_time: @metric_value,
-          metric_name: @metric_name,
-          process_type: @process_type,
-          queue_name: @queue_name
-        }.compact
-      end
-
-      def build_url(params)
-        url = URI.parse(@config.metrics_server_url)
-        url.query = URI.encode_www_form(params)
-        url
-      end
-
-      def post_request(url)
-        http_request(url, self.class.build_post_request(url, @config.metrics_server_auth_token))
-      end
-
-      def self.build_batch_payload(metrics, process_type, queue_name, config)
-        {
-          app_name: config.app_name,
-          process_type: process_type,
-          queue_name: queue_name,
-          metrics: metrics.map { |m| { metric_name: m[:metric_name], metric_value: m[:metric_value].to_i } }
-        }.compact
-      end
-
-      def self.post_batch_request(url, payload, config)
-        uri = URI.parse(url)
-        request = build_post_request(uri, config.metrics_server_auth_token)
-        request.body = JSON.generate(payload)
-        request["Content-Type"] = "application/json"
-        
-        http_request(uri, request)
-      rescue StandardError => e
-        NeetoDeploy::Logger.logger.error("Error batch reporting metrics: #{e.message}")
-        raise
-      end
-
-      def self.build_post_request(uri, auth_token)
-        post = Net::HTTP::Post.new(uri)
-        post["AuthToken"] = auth_token
-        post
-      end
+    def common_params
+      {
+        app_name: @config.app_name,
+        queue_time: @metric_value, # Keep queue_time parameter name for backward compatibility with metrics server
+        metric_name: @metric_name,
+        process_type: @process_type
+      }
+    end
 
-      def self.encode_form_data(payload)
-        form_parts = [
-          "app_name=#{encode_param(payload[:app_name])}",
-          "process_type=#{encode_param(payload[:process_type])}"
-        ]
-        
-        form_parts << "queue_name=#{encode_param(payload[:queue_name])}" if payload[:queue_name]
-        
-        if payload[:metrics].is_a?(Array)
-          payload[:metrics].each do |metric|
-            form_parts << "metrics[][metric_name]=#{encode_param(metric[:metric_name])}"
-            form_parts << "metrics[][metric_value]=#{encode_param(metric[:metric_value])}"
-          end
-        end
-        
-        form_parts.join("&")
-      end
+    def post_request(url)
+      post = Net::HTTP::Post.new(url)
+      post["AuthToken"] = @config.metrics_server_auth_token
 
-      def self.encode_param(value)
-        URI.encode_www_form_component(value.to_s)
+      Net::HTTP.start(url.host, url.port, use_ssl: false) do |http|
+        http.request(post)
       end
+    end
 
-      def self.http_request(uri, request)
-        Net::HTTP.start(uri.host, uri.port, use_ssl: false) do |http|
-          http.request(request)
-        end
-      end
+    def build_url(params = {})
+      exporter_url = URI.parse(@config.metrics_server_url)
+      exporter_url.query = URI.encode_www_form(params)
 
-      def http_request(uri, request)
-        self.class.http_request(uri, request)
-      end
+      exporter_url
+    end
   end
 end

data/lib/neetodeploy/autoscale/sidekiq/metrics_collector.rb

@@ -81,7 +81,7 @@ module Neetodeploy
       end
 
       def report_sidekiq_metric(queue_name, queue_time)
-        Reporter.new(queue_time, "sidekiq_queue_time", "worker", queue_name).report
+        Reporter.new(queue_time, "sidekiq_queue_time", Config.instance.process_type, queue_name).report
       end
     end
   end

data/lib/neetodeploy/autoscale/version.rb

@@ -2,6 +2,6 @@
 
 module Neetodeploy
   module Autoscale
-    VERSION = "2.1.5"
+    VERSION = "2.1.6"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neetodeploy-autoscale
 version: !ruby/object:Gem::Version
-  version: 2.1.5
+  version: 2.1.6
 platform: ruby
 authors:
 - Sreeram Venkitesh
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-27 00:00:00.000000000 Z
+date: 2026-02-20 00:00:00.000000000 Z
 dependencies: []
 description: For automatically scaling your Rails application based on network metrics
 email:
@@ -56,7 +56,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: neetoDeploy autoscaler gem