neetodeploy-autoscale 2.0.6 → 2.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bffc52d124f0b677da6669f6b34b26347b0710396d362a17af10cb22dbf029a9
-  data.tar.gz: dd98640212220a0d4426d2fce3066f4764e1194a79da602b03428bc0c10e7dc3
+  metadata.gz: 5064a81417af764a12450cf56db7a8dd1e6b15c784536808ffcb84be9603b255
+  data.tar.gz: d2bcff1b1bc78f3dc00996c3149d3cba1bd25b78bfbfc6ef8f08e66357464068
 SHA512:
-  metadata.gz: 1e1b0fe71a3a89605214d79c971f63f52bbd75804dabf4b75b817824e65941a861fe7f32f159efc7126f5d53da8b1755b954d96efe8bb66341097a9afcad38a6
-  data.tar.gz: fa8e816a7be8dbdb7395272cd1c4ce67509b1048fb41feca137a62802ffb8607ebc3edc399c17faaf1a9fdbcfce5d5c6ef39ca5f0bf7cd959badcf1ebc46ce78
+  metadata.gz: 738f8a948ac3a6767b200c41fe4175a17e5a57c253931cc50c0cc875115a9bc9decfe0851a28933254928107c7f7993b2825c735649f565d83358891bbe12acb
+  data.tar.gz: d631a416a5c2e441545081db9545eca86ebe52756e273bb6124083b05d77c9a4a5d8225f2bf80a5d951752fcb148b102fd182fd87a6f733fb4c0c5299c6a1613

data/lib/neetodeploy/autoscale/config.rb

@@ -2,29 +2,35 @@ module Neetodeploy
   class Config
     include Singleton
 
-    attr_accessor :disable_auto_scale_gem, :disable_sidekiq_metrics, :app_name, :metrics_server_url,
-                  :metrics_server_auth_token, :report_interval_seconds, :use_puma_queue_size
+    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
 
     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 = "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"
+      @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"
     end
 
     def gem_disabled?
-      disable_auto_scale_gem == "true"
+      @gem_disabled
     end
 
     def sidekiq_metrics_disabled?
-      disable_sidekiq_metrics == "true"
+      @sidekiq_metrics_disabled
     end
 
-    def use_puma_queue_size?
-      use_puma_queue_size
+    def batch_processing_enabled?
+      @batch_processing_enabled
     end
   end
 end

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "singleton"
-require "json"
 require "neetodeploy/autoscale/reporter"
 require "neetodeploy/autoscale/logger"
 require "neetodeploy/autoscale/config"
@@ -13,16 +12,17 @@ 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!
-        config = Config.instance
-        mode = config.use_puma_queue_size? ? "Puma queue size" : "response time"
-        logger.info("Starting background worker to collect #{mode} metrics")
+        logger.info("Starting background worker to collect metrics")
         @pid = Process.pid
-        start_thread_with_collector_loop
+        start_collector_thread
       end
 
       def stop!
@@ -35,83 +35,74 @@ module Neetodeploy
         @pid == Process.pid && @thread&.alive?
       end
 
-      def start_thread_with_collector_loop(config = Config.instance)
+      private
+
+      def start_collector_thread(config = Config.instance)
         @thread = Thread.new do
           loop do
             begin
-              metrics_store = MetricsStore.instance unless config.use_puma_queue_size?
-              loop do
-                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
+              metrics_store = MetricsStore.instance
+              collect_and_report_loop(metrics_store, config)
             rescue StandardError => e
-              logger.error("Rails metrics collector thread terminated with error: #{e.message}")
-              logger.error(e.backtrace.join("\n")) if e.backtrace
-              
-              # Only restart if we're still the same process and thread should continue
-              break unless @pid == Process.pid && !@thread.nil?
-              
-              logger.info("Restarting Rails metrics collector thread")
-              sleep(5)
+              handle_collection_error(e, config)
             end
           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
+
       def run_queue_time_collection(metrics_store, config)
         return if config.gem_disabled?
 
         data = metrics_store.flush
         return if data.empty?
 
-        average_queue_time = data.sum / data.size
-        Reporter.new(average_queue_time, "queue_time", "web").report
+        if config.batch_processing_enabled?
+          report_batch_metrics(data, config)
+        else
+          report_average_metric(data, config)
+        end
       end
 
-      def run_puma_metrics_collection(config)
-        return unless puma_available?
-        return if config.gem_disabled?
+      def report_batch_metrics(data, config)
+        sorted_data = data.sort
+        size = sorted_data.size
 
-        begin
-          queue_size = get_puma_queue_size
-          return if queue_size.nil?
+        metrics = [
+          { metric_name: "queue_time_p90", metric_value: percentile_value(sorted_data, size, 0.90) },
+          { metric_name: "queue_time_p95", metric_value: percentile_value(sorted_data, size, 0.95) },
+          { metric_name: "queue_time_p99", metric_value: percentile_value(sorted_data, size, 0.99) },
+          { metric_name: "queue_time", metric_value: data.sum / data.size }
+        ]
 
-          Reporter.new(queue_size, "puma_queue_size", "web").report
-        rescue StandardError => e
-          logger.error("Error collecting Puma queue size metrics: #{e.message}")
-        end
+        Reporter.report_batch(metrics, "web", nil, config)
       end
 
-      private
+      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
 
-        def puma_available?
-          defined?(::Puma) && ::Puma.respond_to?(:stats)
-        end
+      def percentile_value(sorted_data, size, percentile)
+        index = [(size * percentile).ceil - 1, 0].max
+        sorted_data[index]
+      end
 
-        def get_puma_queue_size
-          stats_json = ::Puma.stats
-          return nil if stats_json.nil? || stats_json.empty?
+      def handle_collection_error(error, config)
+        logger.error("Rails metrics collector thread error: #{error.message}")
+        logger.error(error.backtrace.join("\n")) if error.backtrace
 
-          stats = JSON.parse(stats_json)
+        should_restart = @pid == Process.pid && @thread
+        logger.info("Restarting Rails metrics collector thread") if should_restart
 
-          # 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
+        sleep(RESTART_DELAY) if should_restart
+      end
     end
   end
 end

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

@@ -11,16 +11,21 @@ module Neetodeploy
 
       def initialize
         @metrics = []
+        @mutex = Mutex.new
       end
 
       def push(queue_time)
-        @metrics << queue_time
+        @mutex.synchronize do
+          @metrics << queue_time
+        end
       end
 
       def flush
-        result = @metrics
-        @metrics = []
-        result
+        @mutex.synchronize do
+          result = @metrics
+          @metrics = []
+          result
+        end
       end
     end
   end

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

@@ -3,7 +3,6 @@
 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
@@ -13,18 +12,13 @@ module Neetodeploy
       end
 
       def call(env)
-        config = Config.instance
+        metrics = Metrics.new(env)
+        queue_time = metrics.queue_time unless metrics.ignore?
         MetricsCollector.start
 
-        # 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
+        if queue_time
+          store = MetricsStore.instance
+          store.push queue_time
         end
 
         @app.call(env)

data/lib/neetodeploy/autoscale/reporter.rb

@@ -2,6 +2,7 @@
 
 require "net/http"
 require "time"
+require "json"
 require "neetodeploy/autoscale/config"
 require "neetodeploy/autoscale/logger"
 
@@ -18,39 +19,100 @@ module Neetodeploy
     end
 
     def report
-      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}")
-
+      url = build_url(common_params)
+      logger.info("Reporting #{@metric_name} for #{@process_type}: #{@metric_value}")
       post_request(url)
     end
 
-    private
+    def self.report_batch(metrics, process_type, queue_name = nil, config = Config.instance)
+      return if metrics.empty?
 
-    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
-      }
+      payload = build_batch_payload(metrics, process_type, queue_name, config)
+      url = config.batch_processing_enabled? ? config.metrics_server_batch_url : config.metrics_server_url
+      
+      logger.info("Batch reporting #{metrics.size} metrics for #{process_type}")
+      post_batch_request(url, payload, config)
     end
 
-    def post_request(url)
-      post = Net::HTTP::Post.new(url)
-      post["AuthToken"] = @config.metrics_server_auth_token
+    private
 
-      Net::HTTP.start(url.host, url.port, use_ssl: false) do |http|
-        http.request(post)
+      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
-    end
 
-    def build_url(params = {})
-      exporter_url = URI.parse(@config.metrics_server_url)
-      exporter_url.query = URI.encode_www_form(params)
+      def build_url(params)
+        url = URI.parse(@config.metrics_server_url)
+        url.query = URI.encode_www_form(params)
+        url
+      end
 
-      exporter_url
-    end
+      def post_request(url)
+        http_request(url, 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 = encode_form_data(payload)
+        request["Content-Type"] = "application/x-www-form-urlencoded"
+        
+        http_request(uri, request)
+      rescue StandardError => e
+        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 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 self.encode_param(value)
+        URI.encode_www_form_component(value.to_s)
+      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 http_request(uri, request)
+        self.class.http_request(uri, request)
+      end
   end
 end

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

@@ -29,30 +29,24 @@ module Neetodeploy
       end
 
       def running?
-        @pid == Process.pid && @thread&.alive?
+        @pid == Process.pid and @thread&.alive?
       end
 
       def start_thread_with_collector_loop(config = Config.instance)
         @thread = Thread.new do
-          # Use a non-recursive loop pattern to avoid SystemStackError and ThreadError on shutdown
           loop do
-            begin
-              loop do
-                run_sidekiq_metrics_collection
-                multiplier = 1 - (rand / 4)
-                sleep config.report_interval_seconds * multiplier
-              end
-            rescue StandardError => e
-              logger.error("Sidekiq metrics collector thread terminated with error: #{e.message}")
-              logger.error(e.backtrace.join("\n")) if e.backtrace
-              
-              # Only restart if we're still the same process and thread should continue
-              # Check if Sidekiq is shutting down to avoid ThreadError during shutdown
-              break unless @pid == Process.pid && !@thread.nil? && sidekiq_running?
-              
-              logger.info("Restarting Sidekiq metrics collector thread")
-              sleep(5)
-            end
+            run_sidekiq_metrics_collection
+            multiplier = 1 - (rand / 4)
+            sleep config.report_interval_seconds * multiplier
+          end
+        rescue StandardError => e
+          logger.error("Sidekiq 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 Sidekiq metrics collector thread")
+            sleep(5)
+            start_thread_with_collector_loop
           end
         end
       end
@@ -79,11 +73,6 @@ module Neetodeploy
         defined?(::Sidekiq) && ::Sidekiq.respond_to?(:redis)
       end
 
-      def sidekiq_running?
-        # Check if Sidekiq server is still running to avoid restarting during shutdown
-        defined?(::Sidekiq) && ::Sidekiq.respond_to?(:server?) && ::Sidekiq.server?
-      end
-
       def collect_queue_metrics(queue)
         queue_name = queue.name
         latency_ms = (queue.latency * 1000).ceil

data/lib/neetodeploy/autoscale/version.rb

@@ -2,6 +2,6 @@
 
 module Neetodeploy
   module Autoscale
-    VERSION = "2.0.6"
+    VERSION = "2.0.9"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: neetodeploy-autoscale
 version: !ruby/object:Gem::Version
-  version: 2.0.6
+  version: 2.0.9
 platform: ruby
 authors:
 - Sreeram Venkitesh
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-11-14 00:00:00.000000000 Z
+date: 2025-11-25 00:00:00.000000000 Z
 dependencies: []
 description: For automatically scaling your Rails application based on network metrics
 email: