rails-autoscale-core 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 957a594b6d2686be815ed71d6c84ffcc92e14a14f5a9035fb12f92d6f979a400
+  data.tar.gz: b8cb713fb2731acbc11724097425d497c1f48e5bacaeff5cc41410a8b031f0a3
+SHA512:
+  metadata.gz: 4b79400a71ac5f68401be26efa1bcc9e723b37d55c23802fb0ec30a9d1963bc892ac7b0c8067f11cddc802ffbd3dffd2cc80d7895ab7a1be89d0a7aebcff5232
+  data.tar.gz: f8940544874532959ae2ab3d5405c7087023a742a4f2a365d6ae4a2b15a602e6a41f9c6862d3171b55e4000e7c08008d37781f77531c0c492ea69c926a0377c1

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:
+    rails-autoscale-core (1.0.0)
+
+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
+  minitest
+  rails-autoscale-core!
+  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/lib/rails-autoscale-core.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "rails_autoscale/config"
+require "rails_autoscale/version"
+
+module RailsAutoscale
+  # Allows configuring Rails Autoscale through a block, usually defined during application initialization.
+  #
+  # Example:
+  #
+  #    RailsAutoscale.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, expose_config: nil)
+    Config.expose_adapter_config(expose_config) if expose_config
+    @adapters << Adapter.new(identifier, adapter_info, metrics_collector)
+  end
+
+  add_adapter :"rails-autoscale-core", {
+    adapter_version: VERSION,
+    language_version: RUBY_VERSION
+  }
+end
+
+Judoscale = RailsAutoscale

data/lib/rails_autoscale/adapter_api.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "rails_autoscale/logger"
+
+module RailsAutoscale
+  class AdapterApi
+    include Logger
+
+    SUCCESS = "success"
+
+    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)
+      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/rails_autoscale/config.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "logger"
+
+module RailsAutoscale
+  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 :identifier, :enabled, :max_queues, :queues, :queue_filter, :track_busy_jobs
+
+      def initialize(identifier)
+        @identifier = identifier
+        reset
+      end
+
+      def reset
+        @enabled = true
+        @max_queues = 20
+        @queues = []
+        @queue_filter = DEFAULT_QUEUE_FILTER
+        @track_busy_jobs = false
+      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
+    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["RAILS_AUTOSCALE_URL"] || ENV["JUDOSCALE_URL"]
+      @log_tag = ENV["JUDOSCALE_URL"] ? "Judoscale" : "RailsAutoscale"
+      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["RAILS_AUTOSCALE_LOG_LEVEL"] || ENV["JUDOSCALE_LOG_LEVEL"]
+      @logger = ::Logger.new($stdout)
+
+      self.class.adapter_configs.each(&:reset)
+    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.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 to_s
+      "#{@dyno}##{Process.pid}"
+    end
+
+    def ignore_large_requests?
+      @max_request_size_bytes
+    end
+  end
+end

data/lib/rails_autoscale/job_metrics_collector/active_record_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RailsAutoscale
+  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(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/rails_autoscale/job_metrics_collector.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "set"
+require "rails_autoscale/metrics_collector"
+require "rails_autoscale/logger"
+
+module RailsAutoscale
+  class JobMetricsCollector < MetricsCollector
+    include RailsAutoscale::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
+      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/rails_autoscale/logger.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "rails_autoscale/config"
+require "logger"
+
+module RailsAutoscale
+  module Logger
+    def logger
+      @logger ||= LoggerProxy.new(Config.instance.logger, Config.instance.log_level)
+    end
+  end
+
+  class LoggerProxy < Struct.new(:logger, :log_level)
+    %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 = +"[#{Config.instance.log_tag}]"
+      tag << " [#{tag_level}]" if tag_level
+      msgs.map { |msg| "#{tag} #{msg}" }.join("\n")
+    end
+  end
+end

data/lib/rails_autoscale/metric.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module RailsAutoscale
+  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/rails_autoscale/metrics_collector.rb

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

data/lib/rails_autoscale/metrics_store.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "rails_autoscale/metric"
+require "rails_autoscale/report"
+
+module RailsAutoscale
+  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/rails_autoscale/report.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RailsAutoscale
+  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.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/rails_autoscale/reporter.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require "singleton"
+require "rails_autoscale/config"
+require "rails_autoscale/logger"
+require "rails_autoscale/adapter_api"
+require "rails_autoscale/job_metrics_collector"
+require "rails_autoscale/web_metrics_collector"
+
+module RailsAutoscale
+  class Reporter
+    include Singleton
+    include Logger
+
+    def self.start(config = Config.instance, adapters = RailsAutoscale.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: RAILS_AUTOSCALE_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(RailsAutoscale.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/rails_autoscale/request_metrics.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RailsAutoscale
+  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/rails_autoscale/request_middleware.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "rails_autoscale/metrics_store"
+require "rails_autoscale/reporter"
+require "rails_autoscale/logger"
+require "rails_autoscale/request_metrics"
+
+module RailsAutoscale
+  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["RailsAutoscale.queue_time"] = queue_time
+        store.push :qt, queue_time
+
+        unless network_time.zero?
+          env["RailsAutoscale.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/rails_autoscale/version.rb

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

data/lib/rails_autoscale/web_metrics_collector.rb

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

data/rails-autoscale-core.gemspec

@@ -0,0 +1,27 @@
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rails_autoscale/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "rails-autoscale-core"
+  spec.version = RailsAutoscale::VERSION
+  spec.authors = ["Adam McCrea", "Carlos Antonio da Silva"]
+  spec.email = ["adam@adamlogic.com"]
+
+  spec.summary = "This gem works with the Rails Autoscale Heroku add-on to automatically scale your web and worker dynos."
+  spec.homepage = "https://railsautoscale.com"
+  spec.license = "MIT"
+
+  spec.metadata = {
+    "homepage_uri" => "https://railsautoscale.com",
+    "bug_tracker_uri" => "https://github.com/rails-autoscale/rails-autoscale-gems/issues",
+    "documentation_uri" => "https://railsautoscale.com/docs",
+    "changelog_uri" => "https://github.com/rails-autoscale/rails-autoscale-gems/blob/main/CHANGELOG.md",
+    "source_code_uri" => "https://github.com/rails-autoscale/rails-autoscale-gems"
+  }
+
+  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

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification
+name: rails-autoscale-core
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Adam McCrea
+- Carlos Antonio da Silva
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-09-07 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- adam@adamlogic.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- lib/rails-autoscale-core.rb
+- lib/rails_autoscale/adapter_api.rb
+- lib/rails_autoscale/config.rb
+- lib/rails_autoscale/job_metrics_collector.rb
+- lib/rails_autoscale/job_metrics_collector/active_record_helper.rb
+- lib/rails_autoscale/logger.rb
+- lib/rails_autoscale/metric.rb
+- lib/rails_autoscale/metrics_collector.rb
+- lib/rails_autoscale/metrics_store.rb
+- lib/rails_autoscale/report.rb
+- lib/rails_autoscale/reporter.rb
+- lib/rails_autoscale/request_metrics.rb
+- lib/rails_autoscale/request_middleware.rb
+- lib/rails_autoscale/version.rb
+- lib/rails_autoscale/web_metrics_collector.rb
+- rails-autoscale-core.gemspec
+homepage: https://railsautoscale.com
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://railsautoscale.com
+  bug_tracker_uri: https://github.com/rails-autoscale/rails-autoscale-gems/issues
+  documentation_uri: https://railsautoscale.com/docs
+  changelog_uri: https://github.com/rails-autoscale/rails-autoscale-gems/blob/main/CHANGELOG.md
+  source_code_uri: https://github.com/rails-autoscale/rails-autoscale-gems
+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: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key:
+specification_version: 4
+summary: This gem works with the Rails Autoscale Heroku add-on to automatically scale
+  your web and worker dynos.
+test_files: []