rails-autoscale-core 1.7.0 → 1.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 40bcfbeb0f24259c8b3fe73b8bc616c7d90ddf6b686b8305e595ef8f4509b43d
-  data.tar.gz: 4d786678ce524cbdcc877dc69cd55447ac8c8abe4494c08e07055bb030c0f178
+  metadata.gz: 70720cd6d5ca5dbc3a6db014a65f971bf67cdadff8d6e4d1719dfce777f3c923
+  data.tar.gz: 2498e1529681cfdaa404325a8c2fd8af0f48b7bc38ed5fe08dc2b8de05d93d89
 SHA512:
-  metadata.gz: e7743fca319ec47effa3e5c6ed5e9efbd357421df3453345130baeb3f7e46b8adc04867b52c0000cbda760961e6dd94775ee6b01e5156f14c78d758ae06cd089
-  data.tar.gz: 6d2257ae9a63b80fe810c4d0e4dc0f6a2b815471a5b32ff450adb765bb87bc669438de1761e61fb521bf81464ca0b07db3666c3b2b52ac1b7fad1bd9b8d7db75
+  metadata.gz: 943c4ef2b68828dfc94c9c595b7dc54e827b33069754d647ad150944f9c17626c07f05b9901bc0a4943079d90c93726d5ed75ae4778b69f908ef91c88c12de82
+  data.tar.gz: 401cd2b61a54bb403540563600d1157a5a5662adbe979b128ef600e5b967ca8352af614378b9e34ca1025438f04222ef00dfaf94fda3dcbeb348b42fe81043a6

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails-autoscale-core
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.8.0
 platform: ruby
 authors:
 - Adam McCrea
@@ -10,8 +10,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-05-03 00:00:00.000000000 Z
-dependencies: []
+date: 2024-07-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: judoscale-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.8.0
 description: 
 email:
 - hello@judoscale.com
@@ -19,26 +33,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- Gemfile
-- Rakefile
-- judoscale-ruby.gemspec
-- lib/judoscale-ruby.rb
-- lib/judoscale/adapter_api.rb
-- lib/judoscale/config.rb
-- lib/judoscale/job_metrics_collector.rb
-- lib/judoscale/job_metrics_collector/active_record_helper.rb
-- lib/judoscale/logger.rb
-- lib/judoscale/metric.rb
-- lib/judoscale/metrics_collector.rb
-- lib/judoscale/metrics_store.rb
-- lib/judoscale/report.rb
-- lib/judoscale/reporter.rb
-- lib/judoscale/request_metrics.rb
-- lib/judoscale/request_middleware.rb
-- lib/judoscale/version.rb
-- lib/judoscale/web_metrics_collector.rb
 - lib/rails-autoscale-core.rb
-- rails-autoscale-core.gemspec
 homepage: https://judoscale.com
 licenses:
 - MIT
@@ -56,14 +51,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: Autoscaling for Ruby.

data/Gemfile

@@ -1,9 +0,0 @@
-source "https://rubygems.org"
-
-gemspec name: "judoscale-ruby"
-
-gem "rake", ">= 12.3.3"
-gem "minitest"
-gem "minitest-stub-const"
-gem "webmock"
-gem "debug"

data/Rakefile

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "lib"
-  t.libs << "test"
-  t.test_files = FileList["test/**/*_test.rb"]
-end
-
-task default: :test

data/judoscale-ruby.gemspec

@@ -1,27 +0,0 @@
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "judoscale/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "judoscale-ruby"
-  spec.version = Judoscale::VERSION
-  spec.authors = ["Adam McCrea", "Carlos Antonio da Silva", "Jon Sullivan"]
-  spec.email = ["hello@judoscale.com"]
-
-  spec.summary = "Autoscaling for Ruby."
-  spec.homepage = "https://judoscale.com"
-  spec.license = "MIT"
-
-  spec.metadata = {
-    "homepage_uri" => "https://judoscale.com",
-    "bug_tracker_uri" => "https://github.com/judoscale/judoscale-ruby/issues",
-    "documentation_uri" => "https://judoscale.com/docs",
-    "changelog_uri" => "https://github.com/judoscale/judoscale-ruby/blob/main/CHANGELOG.md",
-    "source_code_uri" => "https://github.com/judoscale/judoscale-ruby"
-  }
-
-  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.require_paths = ["lib"]
-
-  spec.required_ruby_version = ">= 2.6.0"
-end

data/lib/judoscale/adapter_api.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-require "net/http"
-require "uri"
-require "json"
-require "judoscale/logger"
-
-module Judoscale
-  class AdapterApi
-    include Logger
-
-    SUCCESS = "success"
-    TRANSIENT_ERRORS = [
-      Errno::ECONNREFUSED,
-      Errno::ECONNRESET,
-      Net::OpenTimeout,
-      Net::ReadTimeout,
-      OpenSSL::SSL::SSLError
-    ]
-
-    def initialize(config)
-      @config = config
-    end
-
-    def report_metrics(report_json)
-      post_json "/v3/reports", report_json
-    end
-
-    private
-
-    def post_json(path, data)
-      headers = {"Content-Type" => "application/json"}
-      post_raw path: path, body: JSON.dump(data), headers: headers
-    end
-
-    def post_raw(options)
-      attempts ||= 1
-      uri = URI.parse("#{@config.api_base_url}#{options.fetch(:path)}")
-      ssl = uri.scheme == "https"
-
-      response = Net::HTTP.start(uri.host, uri.port, use_ssl: ssl) do |http|
-        request = Net::HTTP::Post.new(uri.request_uri, options[:headers] || {})
-        request.body = options.fetch(:body)
-
-        logger.debug "Posting #{request.body.size} bytes to #{uri}"
-        http.request(request)
-      end
-
-      case response.code.to_i
-      when 200...300 then SuccessResponse.new(response.body)
-      else FailureResponse.new([response.code, response.message].join(" - "))
-      end
-    rescue *TRANSIENT_ERRORS => ex
-      if attempts < 3
-        # TCP timeouts happen sometimes, but they can usually be successfully retried in a moment
-        sleep 0.01
-        attempts += 1
-        retry
-      else
-        FailureResponse.new("Could not connect to #{uri.host}: #{ex.inspect}")
-      end
-    end
-
-    class SuccessResponse < Struct.new(:body)
-      def data
-        JSON.parse(body)
-      rescue TypeError
-        {}
-      end
-    end
-
-    class FailureResponse < Struct.new(:failure_message)
-    end
-  end
-end

data/lib/judoscale/config.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require "singleton"
-require "logger"
-
-module Judoscale
-  class Config
-    class RuntimeContainer < String
-      # Since Heroku exposes ordinal dyno 'numbers', we can tell if the current
-      # instance is redundant (and thus skip collecting some metrics sometimes)
-      # We don't have a means of determining that on Render though — so every
-      # instance must be considered non-redundant
-      def redundant_instance?
-        instance_number = split(".")[1].to_i
-        instance_number > 1
-      end
-    end
-
-    class JobAdapterConfig
-      UUID_REGEXP = /[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}/
-      DEFAULT_QUEUE_FILTER = ->(queue_name) { !UUID_REGEXP.match?(queue_name) }
-
-      attr_accessor :identifier, :enabled, :max_queues, :queues, :queue_filter
-      attr_reader :track_busy_jobs
-
-      def initialize(identifier, support_busy_jobs: true)
-        @identifier = identifier
-        @support_busy_jobs = support_busy_jobs
-        reset
-      end
-
-      def reset
-        @enabled = true
-        @queues = []
-        @queue_filter = DEFAULT_QUEUE_FILTER
-
-        # Support for deprecated legacy env var configs.
-        @max_queues = (ENV["RAILS_AUTOSCALE_MAX_QUEUES"] || 20).to_i
-        self.track_busy_jobs = ENV["RAILS_AUTOSCALE_LONG_JOBS"] == "true"
-      end
-
-      def track_busy_jobs=(value)
-        if value && !@support_busy_jobs
-          raise "[#{Config.instance.log_tag}] #{identifier} does not support busy jobs"
-        end
-
-        @track_busy_jobs = value
-      end
-
-      def as_json
-        {
-          identifier => {
-            max_queues: max_queues,
-            queues: queues,
-            queue_filter: queue_filter != DEFAULT_QUEUE_FILTER,
-            track_busy_jobs: track_busy_jobs
-          }
-        }
-      end
-    end
-
-    include Singleton
-
-    @adapter_configs = []
-    class << self
-      attr_reader :adapter_configs
-    end
-
-    def self.expose_adapter_config(config_instance)
-      adapter_configs << config_instance
-
-      define_method(config_instance.identifier) do
-        config_instance
-      end
-    end
-
-    attr_accessor :api_base_url, :report_interval_seconds,
-      :max_request_size_bytes, :logger, :log_tag, :current_runtime_container
-    attr_reader :log_level
-
-    def initialize
-      reset
-    end
-
-    def reset
-      @api_base_url = ENV["JUDOSCALE_URL"] || ENV["RAILS_AUTOSCALE_URL"]
-      @log_tag = "Judoscale"
-      @max_request_size_bytes = 100_000 # ignore request payloads over 100k since they skew the queue times
-      @report_interval_seconds = 10
-
-      self.log_level = ENV["JUDOSCALE_LOG_LEVEL"] || ENV["RAILS_AUTOSCALE_LOG_LEVEL"]
-      @logger = ::Logger.new($stdout)
-
-      self.class.adapter_configs.each(&:reset)
-
-      if ENV["RENDER_INSTANCE_ID"]
-        instance = ENV["RENDER_INSTANCE_ID"].delete_prefix(ENV["RENDER_SERVICE_ID"]).delete_prefix("-")
-        @current_runtime_container = RuntimeContainer.new instance
-        # Allow a custom API base URL to be set for Render (for testing)
-        @api_base_url ||= "https://adapter.judoscale.com/api"
-        @api_base_url += "/#{ENV["RENDER_SERVICE_ID"]}"
-      elsif ENV["DYNO"]
-        @current_runtime_container = RuntimeContainer.new ENV["DYNO"]
-      elsif (metadata_uri = ENV["ECS_CONTAINER_METADATA_URI"])
-        @current_runtime_container = RuntimeContainer.new(metadata_uri.split("/").last)
-      else
-        # unsupported platform? Don't want to leave @current_runtime_container nil though
-        @current_runtime_container = RuntimeContainer.new("")
-      end
-    end
-
-    def log_level=(new_level)
-      @log_level = new_level ? ::Logger::Severity.const_get(new_level.to_s.upcase) : nil
-    end
-
-    def as_json
-      adapter_configs_json = self.class.adapter_configs.reduce({}) { |hash, config| hash.merge!(config.as_json) }
-
-      {
-        log_level: log_level,
-        logger: logger.class.name,
-        report_interval_seconds: report_interval_seconds,
-        max_request_size_bytes: max_request_size_bytes
-      }.merge!(adapter_configs_json)
-    end
-
-    def ignore_large_requests?
-      @max_request_size_bytes
-    end
-  end
-end

data/lib/judoscale/job_metrics_collector/active_record_helper.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module Judoscale
-  class JobMetricsCollector
-    module ActiveRecordHelper
-      # Cleanup any whitespace characters (including new lines) from the SQL for simpler logging.
-      # Reference: ActiveSupport's `squish!` method. https://api.rubyonrails.org/classes/String.html#method-i-squish
-      def self.cleanse_sql(sql)
-        sql = sql.dup
-        sql.gsub!(/[[:space:]]+/, " ")
-        sql.strip!
-        sql
-      end
-
-      # This will respect a multiple-database setup, unlike the `table_exists?` method.
-      def self.table_exists_for_model?(model)
-        model.connection.schema_cache.data_source_exists?(model.table_name)
-      rescue ActiveRecord::NoDatabaseError
-        false
-      end
-
-      def self.table_exists?(table_name)
-        ::ActiveRecord::Base.connection.table_exists?(table_name)
-      rescue ActiveRecord::NoDatabaseError
-        false
-      end
-
-      private
-
-      def run_silently(&block)
-        if Config.instance.log_level && ::ActiveRecord::Base.logger.respond_to?(:silence)
-          ::ActiveRecord::Base.logger.silence(Config.instance.log_level) { yield }
-        else
-          yield
-        end
-      end
-
-      def select_rows_silently(sql)
-        run_silently { select_rows_tagged(sql) }
-      end
-
-      def select_rows_tagged(sql)
-        if ActiveRecord::Base.logger.respond_to?(:tagged)
-          ActiveRecord::Base.logger.tagged(Config.instance.log_tag) { select_rows(sql) }
-        else
-          select_rows(sql)
-        end
-      end
-
-      def select_rows(sql)
-        # This ensures the agent doesn't hold onto a DB connection any longer than necessary
-        ActiveRecord::Base.connection_pool.with_connection { |c| c.select_rows(sql) }
-      end
-    end
-  end
-end

data/lib/judoscale/job_metrics_collector.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require "set"
-require "judoscale/metrics_collector"
-require "judoscale/logger"
-
-module Judoscale
-  class JobMetricsCollector < MetricsCollector
-    include Judoscale::Logger
-
-    def self.collect?(config)
-      super && !config.current_runtime_container.redundant_instance? && adapter_config.enabled
-    end
-
-    def self.adapter_name
-      @_adapter_name ||= adapter_identifier.to_s.capitalize.gsub(/(?:_)(.)/i) { $1.upcase }
-    end
-
-    def self.adapter_identifier
-      adapter_config.identifier
-    end
-
-    def self.adapter_config
-      raise "Implement `self.adapter_config` in individual job metrics collectors."
-    end
-
-    def initialize
-      super
-
-      log_msg = +"#{self.class.adapter_name} enabled"
-      log_msg << " with busy job tracking support" if track_busy_jobs?
-      logger.info log_msg
-    end
-
-    # Track the known queues so we can continue reporting on queues that don't
-    # have enqueued jobs at the time of reporting.
-    def queues
-      @queues ||= Set.new([])
-    end
-
-    def queues=(new_queues)
-      @queues = filter_queues(new_queues)
-    end
-
-    def clear_queues
-      @queues = nil
-    end
-
-    private
-
-    def adapter_config
-      self.class.adapter_config
-    end
-
-    def filter_queues(queues)
-      configured_queues = adapter_config.queues
-
-      if configured_queues.empty?
-        configured_filter = adapter_config.queue_filter
-
-        if configured_filter.respond_to?(:call)
-          queues = queues.select { |queue| configured_filter.call(queue) }
-        end
-      else
-        queues = configured_queues
-      end
-
-      queues = filter_max_queues(queues)
-
-      Set.new(queues)
-    end
-
-    # Collect up to the configured `max_queues`, skipping the rest.
-    # We sort queues by name length before making the cut-off, as a simple heuristic to keep the shorter ones
-    # and possibly ignore the longer ones, which are more likely to be dynamically generated for example.
-    def filter_max_queues(queues_to_collect)
-      queues_size = queues_to_collect.size
-      max_queues = adapter_config.max_queues
-
-      if queues_size > max_queues
-        logger.warn "#{self.class.adapter_name} metrics reporting only #{max_queues} queues max, skipping the rest (#{queues_size - max_queues})"
-        queues_to_collect.sort_by(&:length).first(max_queues)
-      else
-        queues_to_collect
-      end
-    end
-
-    # Sample log line for each collection, assuming `sidekiq` as the adapter identifier:
-    #   `sidekiq-qt.default=10ms sidekiq-qd.default=3 sidekiq-busy.default=1`
-    def log_collection(metrics)
-      return if metrics.empty?
-
-      identifier = self.class.adapter_identifier
-      messages = metrics.map { |metric|
-        "#{identifier}-#{metric.identifier}.#{metric.queue_name}=#{metric.value}#{"ms" if metric.identifier == :qt}"
-      }
-      logger.debug messages.join(" ")
-    end
-
-    def track_busy_jobs?
-      adapter_config.track_busy_jobs
-    end
-  end
-end

data/lib/judoscale/logger.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require "judoscale/config"
-require "logger"
-
-module Judoscale
-  module Logger
-    def logger
-      if @logger && @logger.log_level == Config.instance.log_level
-        @logger
-      else
-        @logger = LoggerProxy.new(Config.instance.logger, Config.instance.log_level)
-      end
-    end
-  end
-
-  class LoggerProxy < Struct.new(:logger, :log_level)
-    %w[ERROR WARN INFO DEBUG FATAL].each do |severity_name|
-      severity_level = ::Logger::Severity.const_get(severity_name)
-
-      define_method(severity_name.downcase) do |*messages|
-        if log_level.nil?
-          logger.public_send(severity_name.downcase) { tag(messages) }
-        elsif severity_level >= log_level
-          if severity_level >= logger.level
-            logger.public_send(severity_name.downcase) { tag(messages) }
-          else
-            # Our logger proxy is configured with a lower severity level than the underlying logger,
-            # so send this message using the underlying logger severity instead of the actual severity.
-            logger_severity_name = ::Logger::SEV_LABEL[logger.level].downcase
-            logger.public_send(logger_severity_name) { tag(messages, tag_level: severity_name) }
-          end
-        end
-      end
-    end
-
-    private
-
-    def tag(msgs, tag_level: nil)
-      tag = +"[#{Config.instance.log_tag}]"
-      tag << " [#{tag_level}]" if tag_level
-      msgs.map { |msg| "#{tag} #{msg}" }.join("\n")
-    end
-  end
-end

data/lib/judoscale/metric.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Judoscale
-  class Metric < Struct.new(:identifier, :value, :time, :queue_name)
-    # No queue_name is assumed to be a web request metric
-    # Metrics: qt = queue time (default), qd = queue depth, busy
-    def initialize(identifier, value, time, queue_name = nil)
-      super(identifier, value.to_i, time.utc, queue_name)
-    end
-  end
-end

data/lib/judoscale/metrics_collector.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Judoscale
-  class MetricsCollector
-    def self.collect?(config)
-      true
-    end
-
-    def collect
-      []
-    end
-  end
-end

data/lib/judoscale/metrics_store.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "singleton"
-require "judoscale/metric"
-require "judoscale/report"
-
-module Judoscale
-  class MetricsStore
-    include Singleton
-
-    attr_reader :metrics, :flushed_at
-
-    def initialize
-      @metrics = []
-      @flushed_at = Time.now
-    end
-
-    def push(identifier, value, time = Time.now, queue_name = nil)
-      # If it's been two minutes since clearing out the store, stop collecting metrics.
-      # There could be an issue with the reporter, and continuing to collect will consume linear memory.
-      return if @flushed_at && @flushed_at < Time.now - 120
-
-      @metrics << Metric.new(identifier, value, time, queue_name)
-    end
-
-    def flush
-      @flushed_at = Time.now
-      flushed_metrics = []
-
-      while (metric = @metrics.shift)
-        flushed_metrics << metric
-      end
-
-      flushed_metrics
-    end
-
-    def clear
-      @metrics.clear
-    end
-  end
-end

data/lib/judoscale/report.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module Judoscale
-  class Report
-    attr_reader :adapters, :config, :metrics
-
-    def initialize(adapters, config, metrics = [])
-      @adapters = adapters
-      @config = config
-      @metrics = metrics
-    end
-
-    def as_json
-      {
-        container: config.current_runtime_container,
-        pid: Process.pid,
-        config: config.as_json,
-        adapters: adapters.reduce({}) { |hash, adapter| hash.merge!(adapter.as_json) },
-        metrics: metrics.map { |metric|
-          [
-            metric.time.to_i,
-            metric.value,
-            metric.identifier,
-            metric.queue_name
-          ]
-        }
-      }
-    end
-  end
-end

data/lib/judoscale/reporter.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require "singleton"
-require "judoscale/config"
-require "judoscale/logger"
-require "judoscale/adapter_api"
-require "judoscale/job_metrics_collector"
-require "judoscale/web_metrics_collector"
-
-module Judoscale
-  class Reporter
-    include Singleton
-    include Logger
-
-    def self.start(config = Config.instance, adapters = Judoscale.adapters)
-      instance.start!(config, adapters) unless instance.started?
-    end
-
-    def start!(config, adapters)
-      @pid = Process.pid
-
-      if config.api_base_url.nil? || config.api_base_url.strip.empty?
-        logger.debug "Set api_base_url to enable metrics reporting"
-        return
-      end
-
-      enabled_adapters, skipped_adapters = adapters.partition { |adapter|
-        adapter.metrics_collector&.collect?(config)
-      }
-      metrics_collectors_classes = enabled_adapters.map(&:metrics_collector)
-      adapters_msg = enabled_adapters.map(&:identifier).concat(
-        skipped_adapters.map { |adapter| "#{adapter.identifier}[skipped]" }
-      ).join(", ")
-
-      if metrics_collectors_classes.empty?
-        logger.debug "No metrics need to be collected (adapters: #{adapters_msg})"
-        return
-      end
-
-      logger.info "Reporter starting, will report every ~#{config.report_interval_seconds} seconds (adapters: #{adapters_msg})"
-
-      metrics_collectors = metrics_collectors_classes.map(&:new)
-
-      run_loop(config, metrics_collectors)
-    end
-
-    def run_loop(config, metrics_collectors)
-      @_thread = Thread.new do
-        loop do
-          run_metrics_collection(config, metrics_collectors)
-
-          # Stagger reporting to spread out reports from many processes
-          multiplier = 1 - (rand / 4) # between 0.75 and 1.0
-          sleep config.report_interval_seconds * multiplier
-        end
-      end
-    end
-
-    def run_metrics_collection(config, metrics_collectors)
-      metrics = metrics_collectors.flat_map do |metric_collector|
-        log_exceptions { metric_collector.collect } || []
-      end
-
-      log_exceptions { report(config, metrics) }
-    end
-
-    def started?
-      @pid == Process.pid
-    end
-
-    def stop!
-      @_thread&.terminate
-      @_thread = nil
-      @pid = nil
-    end
-
-    private
-
-    def report(config, metrics)
-      report = Report.new(Judoscale.adapters, config, metrics)
-      logger.info "Reporting #{report.metrics.size} metrics"
-      result = AdapterApi.new(config).report_metrics(report.as_json)
-
-      case result
-      when AdapterApi::SuccessResponse
-        logger.debug "Reported successfully"
-      when AdapterApi::FailureResponse
-        logger.error "Reporter failed: #{result.failure_message}"
-      end
-    end
-
-    def log_exceptions
-      yield
-    rescue => ex
-      # Log the exception but swallow it to keep the thread running and processing reports.
-      # Note: Exceptions in threads other than the main thread will fail silently and terminate it.
-      # https://ruby-doc.org/core-3.1.0/Thread.html#class-Thread-label-Exception+handling
-      logger.error "Reporter error: #{ex.inspect}", *ex.backtrace
-      nil
-    end
-  end
-end

data/lib/judoscale/request_metrics.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-module Judoscale
-  class RequestMetrics
-    MILLISECONDS_CUTOFF = Time.new(2000, 1, 1).to_i * 1000
-    MICROSECONDS_CUTOFF = MILLISECONDS_CUTOFF * 1000
-    NANOSECONDS_CUTOFF = MICROSECONDS_CUTOFF * 1000
-
-    attr_reader :request_id, :size, :network_time
-
-    def initialize(env, config = Config.instance)
-      @config = config
-      @request_id = env["HTTP_X_REQUEST_ID"]
-      @size = env["rack.input"].respond_to?(:size) ? env["rack.input"].size : 0
-      @network_time = env["puma.request_body_wait"].to_i
-      @request_start_header = env["HTTP_X_REQUEST_START"]
-    end
-
-    def ignore?
-      @config.ignore_large_requests? && @size > @config.max_request_size_bytes
-    end
-
-    def started_at
-      if @request_start_header
-        # There are several variants of this header. We handle these:
-        #   - whole milliseconds (Heroku)
-        #   - whole microseconds (???)
-        #   - whole nanoseconds (Render)
-        #   - fractional seconds (NGINX)
-        #   - preceeding "t=" (NGINX)
-        value = @request_start_header.gsub(/[^0-9.]/, "").to_f
-
-        # `value` could be seconds, milliseconds, microseconds or nanoseconds.
-        # We use some arbitrary cutoffs to determine which one it is.
-
-        if value > NANOSECONDS_CUTOFF
-          Time.at(value / 1_000_000_000.0)
-        elsif value > MICROSECONDS_CUTOFF
-          Time.at(value / 1_000_000.0)
-        elsif value > MILLISECONDS_CUTOFF
-          Time.at(value / 1000.0)
-        else
-          Time.at(value)
-        end
-      end
-    end
-
-    def queue_time(now = Time.now)
-      return if started_at.nil?
-
-      queue_time = ((now - started_at) * 1000).to_i
-
-      # Subtract the time Puma spent waiting on the request body, i.e. the network time. It's irrelevant to
-      # capacity-related queue time. Without this, slow clients and large request payloads will skew queue time.
-      queue_time -= network_time
-
-      # Safeguard against negative queue times (should not happen in practice)
-      (queue_time > 0) ? queue_time : 0
-    end
-  end
-end

data/lib/judoscale/request_middleware.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-require "judoscale/metrics_store"
-require "judoscale/reporter"
-require "judoscale/logger"
-require "judoscale/request_metrics"
-
-module Judoscale
-  class RequestMiddleware
-    include Logger
-
-    def initialize(app)
-      @app = app
-    end
-
-    def call(env)
-      request_metrics = RequestMetrics.new(env)
-
-      unless request_metrics.ignore?
-        queue_time = request_metrics.queue_time
-        network_time = request_metrics.network_time
-      end
-
-      Reporter.start
-
-      if queue_time
-        store = MetricsStore.instance
-
-        # NOTE: Expose queue time to the app
-        env["judoscale.queue_time"] = queue_time
-        store.push :qt, queue_time
-
-        unless network_time.zero?
-          env["judoscale.network_time"] = network_time
-          store.push :nt, network_time
-        end
-
-        logger.debug "Request queue_time=#{queue_time}ms network_time=#{network_time}ms request_id=#{request_metrics.request_id} size=#{request_metrics.size}"
-      end
-
-      @app.call(env)
-    end
-  end
-end

data/lib/judoscale/version.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-module Judoscale
-  VERSION = "1.7.0"
-end

data/lib/judoscale/web_metrics_collector.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require "judoscale/metrics_collector"
-require "judoscale/metrics_store"
-
-module Judoscale
-  class WebMetricsCollector < MetricsCollector
-    def collect
-      MetricsStore.instance.flush
-    end
-  end
-end

data/lib/judoscale-ruby.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require "judoscale/config"
-require "judoscale/version"
-
-module Judoscale
-  # Allows configuring Judoscale through a block, usually defined during application initialization.
-  #
-  # Example:
-  #
-  #    Judoscale.configure do |config|
-  #      config.logger = MyLogger.new
-  #    end
-  def self.configure
-    yield Config.instance
-  end
-
-  @adapters = []
-  class << self
-    attr_reader :adapters
-  end
-
-  class Adapter < Struct.new(:identifier, :adapter_info, :metrics_collector)
-    def as_json
-      {identifier => adapter_info}
-    end
-  end
-
-  def self.add_adapter(identifier, adapter_info, metrics_collector: nil, expose_config: nil)
-    Config.expose_adapter_config(expose_config) if expose_config
-    @adapters << Adapter.new(identifier, adapter_info, metrics_collector)
-  end
-
-  add_adapter :"judoscale-ruby", {
-    adapter_version: VERSION,
-    language_version: RUBY_VERSION
-  }
-end
-
-RailsAutoscale = Judoscale

data/rails-autoscale-core.gemspec

@@ -1,27 +0,0 @@
-lib = File.expand_path("../lib", __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "judoscale/version"
-
-Gem::Specification.new do |spec|
-  spec.name = "rails-autoscale-core"
-  spec.version = Judoscale::VERSION
-  spec.authors = ["Adam McCrea", "Carlos Antonio da Silva", "Jon Sullivan"]
-  spec.email = ["hello@judoscale.com"]
-
-  spec.summary = "Autoscaling for Ruby."
-  spec.homepage = "https://judoscale.com"
-  spec.license = "MIT"
-
-  spec.metadata = {
-    "homepage_uri" => "https://judoscale.com",
-    "bug_tracker_uri" => "https://github.com/judoscale/judoscale-ruby/issues",
-    "documentation_uri" => "https://judoscale.com/docs",
-    "changelog_uri" => "https://github.com/judoscale/judoscale-ruby/blob/main/CHANGELOG.md",
-    "source_code_uri" => "https://github.com/judoscale/judoscale-ruby"
-  }
-
-  spec.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.require_paths = ["lib"]
-
-  spec.required_ruby_version = ">= 2.6.0"
-end