judoscale-ruby 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 26e9809db642f08b7291edeae004fb8619f04bbff3130dc6f34043be85a768df
+  data.tar.gz: a2ff6a031395e860a238db874212d4d82e106b8bdb91c2b3d948bb94a7c7a312
+SHA512:
+  metadata.gz: 66423294a4021d1da21f77823d1ede3fbf4204da0ec61c9e90c33fbda2e34a21b77a7d06fcf95e711912ad38ed8d17875c74a8f5b98caefcaaac82b8d26a93e1
+  data.tar.gz: 948b94b9b8000c7af821a0bf3cbfe1f28317ca70a052b11d46b512b01a718d7e7816fc7e2ec4a7f2a545645401585d2baba6a8927f39448c6d11321c376800ae

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rake", ">= 12.3.3"
+gem "minitest"
+gem "webmock"

data/Gemfile.lock

@@ -0,0 +1,36 @@
+PATH
+  remote: .
+  specs:
+    judoscale-ruby (1.0.0.rc1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.8.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    crack (0.4.5)
+      rexml
+    hashdiff (1.0.1)
+    minitest (5.15.0)
+    public_suffix (4.0.6)
+    rake (13.0.6)
+    rexml (3.2.5)
+    webmock (3.14.0)
+      addressable (>= 2.8.0)
+      crack (>= 0.3.2)
+      hashdiff (>= 0.4.0, < 2.0.0)
+
+PLATFORMS
+  arm64-darwin-20
+  arm64-darwin-21
+  x86_64-darwin-21
+  x86_64-linux
+
+DEPENDENCIES
+  judoscale-ruby!
+  minitest
+  rake (>= 12.3.3)
+  webmock
+
+BUNDLED WITH
+   2.3.9

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+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

@@ -0,0 +1,27 @@
+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"]
+  spec.email = ["adam@adamlogic.com"]
+
+  spec.summary = "This gem works with the Judoscale Heroku add-on to automatically scale your web and worker dynos."
+  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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "judoscale/logger"
+
+module Judoscale
+  class AdapterApi
+    include Logger
+
+    SUCCESS = "success"
+
+    def initialize(config)
+      @config = config
+    end
+
+    def report_metrics(report_json)
+      post_json "/v1/metrics", 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)
+      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
+    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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "logger"
+
+module Judoscale
+  class Config
+    class Dyno
+      attr_reader :name, :num
+
+      def initialize(dyno_string)
+        @name, @num = dyno_string.to_s.split(".")
+        @num = @num.to_i
+      end
+
+      def to_s
+        "#{name}.#{num}"
+      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 :enabled, :max_queues, :queues, :queue_filter, :track_busy_jobs
+
+      def initialize
+        @enabled = true
+        @max_queues = 20
+        @queues = []
+        @queue_filter = DEFAULT_QUEUE_FILTER
+        @track_busy_jobs = false
+      end
+
+      def as_json
+        {
+          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.add_adapter_config(identifier, config_class)
+      @adapter_configs[identifier] = config_class
+      attr_reader identifier
+    end
+
+    attr_accessor :api_base_url, :report_interval_seconds, :max_request_size_bytes, :logger
+    attr_reader :dyno, :log_level
+
+    def initialize
+      reset
+    end
+
+    def reset
+      # Allow the API URL to be configured - needed for testing.
+      @api_base_url = ENV["JUDOSCALE_URL"]
+      self.dyno = ENV["DYNO"]
+      @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"]
+      @logger = ::Logger.new($stdout)
+
+      self.class.adapter_configs.each do |identifier, config_class|
+        instance_variable_set(:"@#{identifier}", config_class.new)
+      end
+    end
+
+    def dyno=(dyno_string)
+      @dyno = Dyno.new(dyno_string)
+    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.each_key.with_object({}) do |identifier, hash|
+        hash[identifier] = public_send(identifier).as_json
+      end
+
+      {
+        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 to_s
+      "#{@dyno}##{Process.pid}"
+    end
+
+    def ignore_large_requests?
+      @max_request_size_bytes
+    end
+  end
+end

data/lib/judoscale/job_metrics_collector/active_record_helper.rb

@@ -0,0 +1,39 @@
+# 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
+
+      private
+
+      def select_rows_silently(sql)
+        if Config.instance.log_level && ::ActiveRecord::Base.logger.respond_to?(:silence)
+          ::ActiveRecord::Base.logger.silence(Config.instance.log_level) { select_rows_tagged(sql) }
+        else
+          select_rows_tagged(sql)
+        end
+      end
+
+      def select_rows_tagged(sql)
+        if ActiveRecord::Base.logger.respond_to?(:tagged)
+          ActiveRecord::Base.logger.tagged(Judoscale::LoggerProxy::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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "set"
+require "judoscale/metrics_collector"
+require "judoscale/logger"
+
+module Judoscale
+  class JobMetricsCollector < MetricsCollector
+    include Judoscale::Logger
+
+    # It's redundant to report these metrics from every dyno, so only report from the first one.
+    def self.collect?(config)
+      config.dyno.num == 1 && adapter_config.enabled
+    end
+
+    def self.adapter_name
+      @_adapter_name ||= adapter_identifier.to_s.capitalize.gsub(/(?:_)(.)/i) { $1.upcase }
+    end
+
+    def self.adapter_identifier
+      raise "Implement `self.adapter_identifier` in individual job metrics collectors."
+    end
+
+    def self.adapter_config
+      Config.instance.public_send(adapter_identifier)
+    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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "judoscale/config"
+require "logger"
+
+module Judoscale
+  module Logger
+    def logger
+      @logger ||= LoggerProxy.new(Config.instance.logger, Config.instance.log_level)
+    end
+  end
+
+  class LoggerProxy < Struct.new(:logger, :log_level)
+    TAG = "Judoscale"
+
+    %w[ERROR WARN INFO DEBUG].each do |severity_name|
+      severity_level = ::Logger::Severity.const_get(severity_name)
+
+      define_method(severity_name.downcase) do |*messages|
+        if log_level.nil?
+          logger.add(severity_level) { tag(messages) }
+        elsif severity_level >= log_level
+          if severity_level >= logger.level
+            logger.add(severity_level) { tag(messages) }
+          else
+            logger.add(logger.level) { tag(messages, tag_level: severity_name) }
+          end
+        end
+      end
+    end
+
+    private
+
+    def tag(msgs, tag_level: nil)
+      tag = +"[#{TAG}]"
+      tag << " [#{tag_level}]" if tag_level
+      msgs.map { |msg| "#{tag} #{msg}" }.join("\n")
+    end
+  end
+end

data/lib/judoscale/metric.rb

@@ -0,0 +1,11 @@
+# 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

@@ -0,0 +1,13 @@
+# 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

@@ -0,0 +1,41 @@
+# 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

@@ -0,0 +1,32 @@
+# 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
+      {
+        dyno: config.dyno,
+        pid: Process.pid,
+        config: config.as_json,
+        adapters: adapters.each_with_object({}) { |adapter, hash|
+          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

@@ -0,0 +1,101 @@
+# 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
+        logger.info "Reporter not started: JUDOSCALE_URL is not set"
+        return
+      end
+
+      enabled_adapters = adapters.select { |adapter|
+        adapter.metrics_collector.nil? || adapter.metrics_collector.collect?(config)
+      }
+      metrics_collectors_classes = enabled_adapters.map(&:metrics_collector)
+      metrics_collectors_classes.compact!
+
+      if metrics_collectors_classes.empty?
+        logger.info "Reporter not started: no metrics need to be collected on this dyno"
+        return
+      end
+
+      adapters_msg = enabled_adapters.map(&:identifier).join(", ")
+      logger.info "Reporter starting, will report every #{config.report_interval_seconds} seconds or so. 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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Judoscale
+  class RequestMetrics
+    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
+        # Heroku sets the header as an integer, measured in milliseconds.
+        # If nginx is involved, it might be in seconds with fractional milliseconds,
+        # and it might be preceeded by "t=". We can all cases by removing non-digits
+        # and treating as milliseconds.
+        Time.at(@request_start_header.gsub(/\D/, "").to_i / 1000.0)
+      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

@@ -0,0 +1,44 @@
+# 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

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

data/lib/judoscale/web_metrics_collector.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "judoscale/metrics_collector"
+require "judoscale/metrics_store"
+
+module Judoscale
+  class WebMetricsCollector < MetricsCollector
+    def self.collect?(config)
+      config.dyno.name == "web"
+    end
+
+    def collect
+      MetricsStore.instance.flush
+    end
+  end
+end

data/lib/judoscale-ruby.rb

@@ -0,0 +1,37 @@
+# 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
+
+  Adapter = Struct.new(:identifier, :adapter_info, :metrics_collector) do
+    def as_json
+      {identifier => adapter_info}
+    end
+  end
+
+  def self.add_adapter(identifier, adapter_info, metrics_collector: nil)
+    @adapters << Adapter.new(identifier, adapter_info, metrics_collector)
+  end
+
+  add_adapter :"judoscale-ruby", {
+    adapter_version: VERSION,
+    language_version: RUBY_VERSION
+  }
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: judoscale-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0.rc1
+platform: ruby
+authors:
+- Adam McCrea
+- Carlos Antonio da Silva
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-04-12 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- adam@adamlogic.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- 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
+homepage: https://judoscale.com
+licenses:
+- MIT
+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
+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: 1.3.1
+requirements: []
+rubygems_version: 3.2.32
+signing_key:
+specification_version: 4
+summary: This gem works with the Judoscale Heroku add-on to automatically scale your
+  web and worker dynos.
+test_files: []