autotuner 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3224324bc9bd16905431bdb2e97bc121eb6902945e3b8fcdc4d65037d8805670
-  data.tar.gz: 064b353800288f8b2342926a01b8bcc1bbfdfa58624b317c1b3deca3e9092629
+  metadata.gz: 2a0cbc0a71a4fe3322d56efe07228bc9e9f7abc0e63f5d6449d86bcc8d7e4475
+  data.tar.gz: a07a9184f3615a5e4da4a7d66ffae945e5da377e8cb089a0fcd1b40735c3d093
 SHA512:
-  metadata.gz: 6d3ece545d282a2bebe07e35fc4ef280d4f262a0976a0ab92ec852abd2a1e7d0e9cf9ea0ef517372df69d4930e0ef40a00925665765cbc5c92db962df8beba70
-  data.tar.gz: 1d30e3154fa03d204b9c89e61ff079046519559f0c5ffa1b50451b915199217a03e0180cd66fcc1b57d17b4f0e57bd1ba7ec6bf465e640542599cf3540793b9a
+  metadata.gz: de54a820d1e5674b1a0b14d2519a2bd89e28f0d7d11690cf90e83a1ace67c829a2c9f019d4487952a4d2432146a857dce6905e82513273267ba7835beff2fcaa
+  data.tar.gz: fd56fb285f351006ac7091c24db412a96518d82771beebcbcbd16107d41e0a2a4af382b5ce2a3a719a21fb96aeea20bbd421e429eba568b3cd1d34a39ab58048

data/.rubocop.yml

@@ -8,6 +8,9 @@ AllCops:
   SuggestExtensions: false
   TargetRubyVersion: 2.6
 
+Minitest/AssertInDelta:
+  Enabled: false
+
 Style/StringLiterals:
   Enabled: true
   EnforcedStyle: double_quotes

data/Gemfile

@@ -2,7 +2,7 @@
 
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in gc_tuner.gemspec
+# Specify your gem's dependencies in autotuner.gemspec
 gemspec
 
 gem "rake", "~> 13.0"

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2023 Peter Zhu
+Copyright (c) 2023-present, Shopify Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,34 +1,74 @@
-# GcTuner
+# Autotuner
 
-TODO: Delete this and the text below, and describe your gem
-
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/gc_tuner`. To experiment with that code, run `bin/console` for an interactive prompt.
+Autotuner is a tool designed to help you tune the garbage collector of your Rails app. Autotuner integrates into Rack as a middleware and collects data from the garbage collector between requests. It will then intelligently provide suggestions to tune the garbage collector for faster bootup, warmup, and response times.
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+To install the gem, add it to the application's Gemfile by executing:
+
+```
+$ bundle add autotuner
+```
+
+## Quick start
+
+1. Open the `config.ru` file in your Rails app and add the following line immediately above `run(Rails.application)`:
+   ```ruby
+   use(Autotuner::RackPlugin)
+   ```
+1. Create an initializer in `config/initializers/autotuner.rb`:
+   ```ruby
+   # Enable autotuner. Alternatively, call Autotuner.sample_ratio= with a value
+   # between 0 and 1.0 to sample on a portion of instances.
+   Autotuner.enabled = true
+
+   # This callback is called whenever a suggestion is provided by this gem.
+   # You can output this report to your logging pipeline, stdout, a file,
+   # or somewhere else!
+   Autotuner.reporter = proc do |report|
+     Rails.logger.info(report.to_s)
+   end
+
+   # This (optional) callback is called to provide metrics that can give you
+   # insights about the performance of your app. It's recommended to send this
+   # data to your observability service (e.g. Datadog, Prometheus, New Relic, etc).
+   Autotuner.metrics_reporter = proc do |metrics|
+     # stats is a hash of metric name (string) to integer value.
+     metrics.each do |key, val|
+       StatsD.gauge(key, val)
+     end
+   end
+   ```
+
+## Experimenting with tuning suggestions
 
-Install the gem and add to the application's Gemfile by executing:
+While autotuner aims to comprehensively analyze your traffic to give the suggestion, not all of the suggestions it provides will be perfect. There will be cases where the suggestions it provides may result in undesired outcomes. Therefore, it is NOT recommended to blindly apply suggestions from autotuner, but rather use a scientific approach to experiment with the suggestions. There are a few steps to this.
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+1. Before any suggestions from autotuner is applied, make sure you are collecting system metrics from your Rails app. Send this data to your observability service so you can measure average, 50th percentile, 99th percentile, and 99.9th percentile data.
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+   You can use `Autotuner.metrics_reporter` to collect important metrics from your app, including: GC time, number of major and minor GC cycles, request time, and number of heap pages allocated.
+1. Establish an experimental group of machines/containers in production. Since response times and the state of the garbage collector are highly variable, it's much easier and more reliable to compare two groups at the same time rather than across different time periods with different traffic patterns.
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+   You can do this by assigning a random number to each machine/container at boot, and using that number to determine the group it belongs in. Depending on the traffic of your app, you may want to place between 5% (high traffic apps) to 50% (low traffic apps) in the experimental group.
+1. Apply suggestions from Autotuner one at a time in the experimental group, and observe the impacts of the tuning. You may want to observe the impact over a few days to a week, including warmup performance after a new deploy and long periods of no deploys (such as a weekend).
 
-## Usage
+   If you observe that the suggestion provides positive improvements, then also apply the suggestion to the default group and experiment with the next tuning suggestion provided by Autotuner.
 
-TODO: Write usage instructions here
+   Some suggestions may provide a trade-off. For example, it may improve average response time at the expense of worse extremes (99th or 99.9th percentile). It is up to you to determine whether the trade-off is worth it.
 
-## Development
+   Some suggestions may cause a decrease in performance. In that case, discard the suggestion and experiment with the next suggestion provided by Autotuner.
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+## Configuration
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+- `Autotuner.enabled=`: (required, unless `Autotuner.sample_ratio` is set) Sets whether autotuner is enabled or not. When autotuner is disabled, data is not collected and suggestions are not given. Defaults to `false`.
+- `Autotuner.sample_ratio=`: (optional) Sets the portion of instances where autotuner is enabled. Pass a value between 0 (enabled on no intances) and 1.0 (enabled on all instances). Note that this does not sample reqeusts, but rather samples the portion of instances that have autotuner enabled (it will be enabled for all requests on those instances). Do not configure `Autotuner.enabled=` when you use this option.
+- `Autotuner.reporter=`: (required) Callback called when a heuristic is ready to give a suggestion. The callback will be called with one argument which will be an instance of `Autotuner::Report::Base`. Call `#to_s` on this object to get a string containing instructions and recommendations. You must set this when autotuner is enabled.
+- `Autotuner.debug_reporter=`: (optional) Callback to periodically emit debug messages of internal state of heuristics. The callback will be called with one argument which will be a hash with the heuristic name as the key and the debug message as the value. Regular users do not need to configure this as this is only useful for debugging purposes.
+- `Autotuner.metrics_reporter=`: (optional) Callback to emit useful metrics about your service. The callback will be called with a hash containing the metric names (string) as the key and integer values.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/gc_tuner.
+Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/autotuner.
 
 ## License
 

data/lib/autotuner/configuration.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Autotuner
+  module Configuration
+    DATA_POINTS_COUNT = 1_000
+
+    attr_reader :sample_ratio
+    attr_accessor :reporter
+    attr_accessor :metrics_reporter
+
+    # Set this callback to report debug information periodically.
+    attr_accessor :debug_reporter
+
+    def enabled?
+      @enabled
+    end
+
+    def enabled=(enabled)
+      raise ArgumentError, "cannot configure `enabled` when `sample_ratio` is configured" if sample_ratio
+
+      @enabled = enabled
+    end
+
+    def sample_ratio=(ratio)
+      raise ArgumentError, "`ratio` must be between 0 and 1.0" unless (0..1.0).include?(ratio)
+      if enabled? || enabled? == false
+        raise ArgumentError, "cannot configure `sample_ratio` when `enabled` is configured"
+      end
+
+      @sample_ratio = ratio
+
+      @enabled = rand < ratio
+    end
+  end
+end

data/lib/{gc_tuner → autotuner}/data_structure/data_points.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module GCTuner
+module Autotuner
   module DataStructure
     class DataPoints
       STABLE_RATIO = 0.5
@@ -74,8 +74,14 @@ module GCTuner
           (Math.sqrt((length * sum_x_2) - (sum_x**2)) * Math.sqrt((length * sum_y_2) - (sum_y**2)))
       end
 
-      def to_s
-        inspect
+      def debug_state
+        {
+          samples: @samples,
+          length: @length,
+          compression_ratio: @compression_ratio,
+          temp_sample: @temp_sample,
+          temp_sample_count: @temp_sample_count,
+        }
       end
 
       private

data/lib/autotuner/gc_context.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Autotuner
+  class GCContext
+    HAS_STAT_HEAP = GC.respond_to?(:stat_heap)
+
+    attr_reader :stat, :latest_gc_info
+
+    if HAS_STAT_HEAP
+      attr_reader :stat_heap
+    end
+
+    def initialize
+      @stat = GC.stat
+      @latest_gc_info = GC.latest_gc_info
+
+      if HAS_STAT_HEAP
+        @stat_heap = GC.stat_heap
+      end
+    end
+
+    def update
+      GC.stat(@stat)
+      GC.latest_gc_info(@latest_gc_info)
+
+      if HAS_STAT_HEAP
+        GC.stat_heap(nil, @stat_heap)
+      end
+    end
+  end
+end

data/lib/{gc_tuner → autotuner}/heuristic/base.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module GCTuner
+module Autotuner
   module Heuristic
     class Base
       class << self
@@ -19,15 +19,23 @@ module GCTuner
         end
       end
 
+      def initialize(system_context)
+        @system_context = system_context
+      end
+
+      def name
+        raise NotImplementedError
+      end
+
       def call(request_time, before_gc_context, after_gc_context)
         raise NotImplementedError
       end
 
-      def tuning_message
+      def tuning_report
         raise NotImplementedError
       end
 
-      def debug_message
+      def debug_state
         raise NotImplementedError
       end
     end

data/lib/autotuner/heuristic/gc_compact.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Autotuner
+  module Heuristic
+    class GCCompact < Base
+      class << self
+        private
+
+        def supported?
+          true
+        end
+      end
+
+      def initialize(_system_context)
+        super
+
+        @called_gc_compact = nil
+      end
+
+      def name
+        "GCCompact"
+      end
+
+      def call(request_context)
+        return unless @called_gc_compact.nil?
+
+        @called_gc_compact = request_context.before_gc_context.stat[:compact_count] > 0
+      end
+
+      def tuning_report
+        return if @called_gc_compact
+
+        # Don't give suggestion twice
+        @called_gc_compact = true
+
+        Report::String.new(<<~MSG)
+          The following suggestion runs compaction at boot time, which reduces fragmentation inside of the Ruby heap. This can improve performance and reduce memory usage in forking web servers.
+
+          Before forking your web server, run the following Ruby code:
+
+            3.times { GC.start }
+            GC.compact
+
+          For example, in Puma, add the following code into config/puma.rb:
+
+            before_fork do
+              3.times { GC.start }
+              GC.compact
+            end
+        MSG
+      end
+
+      def debug_state
+        {
+          called_gc_compact: @called_gc_compact,
+        }
+      end
+    end
+  end
+end

data/lib/autotuner/heuristic/heap_size_warmup.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Autotuner
+  module Heuristic
+    class HeapSizeWarmup < Base
+      class << self
+        private
+
+        def supported?
+          # Ruby 3.2 uses multiple heaps but does not support the
+          # RUBY_GC_HEAP_%d_INIT_SLOTS environment variables, so we cannot
+          # accurately tune the heap size.
+          !RUBY_VERSION.start_with?("3.2.")
+        end
+      end
+
+      # Ruby 3.3.0 and later have support for RUBY_GC_HEAP_%d_INIT_SLOTS
+      SUPPORT_MULTI_HEAP_P = RUBY_VERSION >= "3.3.0"
+
+      HEAP_NAMES =
+        if SUPPORT_MULTI_HEAP_P
+          GC.stat_heap.keys.map(&:to_s).freeze
+        else
+          [nil]
+        end
+
+      HEAP_SIZE_CONFIGURATION_DELTA_RATIO = 0.01
+      HEAP_SIZE_CONFIGURATION_DELTA = 1_000
+
+      REPORT_ASSIST_MESSAGE = <<~MSG
+        The following suggestions adjusts the size of heap at boot time, which can improve bootup speed and reduce the time taken for the app to reach peak performance.
+      MSG
+
+      def initialize(_system_context)
+        super
+
+        @heaps_data = Array.new(HEAP_NAMES.length)
+        HEAP_NAMES.length.times do |i|
+          @heaps_data[i] = DataStructure::DataPoints.new(Configuration::DATA_POINTS_COUNT)
+        end
+
+        @given_suggestion = false
+      end
+
+      def name
+        "HeapSizeWarmup"
+      end
+
+      def call(request_context)
+        # We only want to collect data at boot until plateau
+        return if @given_suggestion
+
+        @heaps_data.each_with_index do |data, i|
+          value =
+            if SUPPORT_MULTI_HEAP_P
+              request_context.after_gc_context.stat_heap[i][:heap_eden_slots]
+            else
+              request_context.after_gc_context.stat[:heap_available_slots]
+            end
+
+          data.insert(value)
+        end
+      end
+
+      def tuning_report
+        # Don't give suggestions twice
+        return if @given_suggestion
+        # The request time should plateau
+        return unless @system_context.request_time_data.plateaued?
+
+        @given_suggestion = true
+
+        env_names = []
+        suggested_values = []
+        configured_values = []
+        HEAP_NAMES.each_with_index do |heap_name, i|
+          env_name = env_name_for_heap(heap_name)
+
+          data = @heaps_data[i]
+          suggested_value = data.samples[data.length - 1].to_i
+
+          env_val = ENV[env_name]
+          configured_value = env_val&.to_i
+
+          if configured_value
+            diff = (suggested_value - configured_value).abs
+
+            # Don't report this if it's within the ratio
+            next if diff <= configured_value * HEAP_SIZE_CONFIGURATION_DELTA_RATIO
+            # Don't report this if it's within the delta
+            next if diff <= HEAP_SIZE_CONFIGURATION_DELTA
+          end
+
+          env_names << env_name
+          suggested_values << suggested_value
+          configured_values << configured_value
+        end
+
+        # Don't generate report if there is nothing to report
+        return if suggested_values.empty?
+
+        Report::MultipleEnvironmentVariables.new(REPORT_ASSIST_MESSAGE, env_names, suggested_values, configured_values)
+      end
+
+      def debug_state
+        state = {
+          given_suggestion: @given_suggestion,
+        }
+
+        # Don't output @heaps_data because there is too much data.
+
+        HEAP_NAMES.each do |heap_name|
+          env_var = env_name_for_heap(heap_name)
+          env_val = ENV[env_var]
+          state[:"ENV[#{env_var}]"] = env_val if env_val
+        end
+
+        state
+      end
+
+      def env_name_for_heap(heap_name)
+        if SUPPORT_MULTI_HEAP_P
+          "RUBY_GC_HEAP_#{heap_name}_INIT_SLOTS"
+        else
+          "RUBY_GC_HEAP_INIT_SLOTS"
+        end
+      end
+    end
+  end
+end

data/lib/autotuner/heuristic/malloc.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module Autotuner
+  module Heuristic
+    class Malloc < Base
+      class << self
+        private
+
+        def supported?
+          true
+        end
+      end
+
+      MALLOC_GC_RATIO_THRESHOLD = 0.1
+      MIN_MALLOC_GC = 10
+
+      # From the GC_MALLOC_LIMIT_MIN macro
+      # https://github.com/ruby/ruby/blob/3874381c4483ba7794ac2abf157e265546f9bfa7/gc.c#L312C9-L312C9
+      DEFAULT_MALLOC_LIMIT = 16 * 1024 * 1024
+      # From the GC_MALLOC_LIMIT_MAX macro
+      # https://github.com/ruby/ruby/blob/3874381c4483ba7794ac2abf157e265546f9bfa7/gc.c#L315C9-L315C28
+      DEFAULT_MALLOC_LIMIT_MAX = 32 * 1024 * 1024
+
+      LIMIT_ENV = "RUBY_GC_MALLOC_LIMIT"
+      LIMIT_MAX_ENV = "RUBY_GC_MALLOC_LIMIT_MAX"
+
+      attr_reader :minor_gc_count
+      attr_reader :malloc_gc_count
+
+      def initialize(_system_context)
+        super
+
+        @minor_gc_count = 0
+        @malloc_gc_count = 0
+
+        @given_suggestion = false
+      end
+
+      def name
+        "Malloc"
+      end
+
+      def call(request_context)
+        # gc_by is only useful if we ran at least one minor GC during the request.
+        if request_context.after_gc_context.stat[:minor_gc_count] ==
+            request_context.before_gc_context.stat[:minor_gc_count]
+          return
+        end
+        # gc_by is only useful if it wasn't a major GC.
+        # It is a major GC when where is a major_by reason set.
+        return if request_context.after_gc_context.latest_gc_info[:major_by]
+
+        @minor_gc_count += 1
+        @malloc_gc_count += 1 if request_context.after_gc_context.latest_gc_info[:gc_by] == :malloc
+      end
+
+      def tuning_report
+        # Don't give suggestions twice.
+        return if @given_suggestion
+        # Don't report if there's very few data points
+        return if malloc_gc_count < MIN_MALLOC_GC
+
+        malloc_gc_ratio = malloc_gc_count.to_f / minor_gc_count
+        # Don't report if there's very few malloc GC.
+        return if malloc_gc_ratio <= MALLOC_GC_RATIO_THRESHOLD
+
+        @given_suggestion = true
+
+        Report::MultipleEnvironmentVariables.new(
+          <<~MSG,
+            The following suggestions reduces the number of minor garbage collection cycles, specifically a cycle called "malloc". Your app runs malloc cycles in approximately #{format("%.2f", malloc_gc_ratio * 100)}% of all minor garbage collection cycles.
+
+            Reducing minor garbage collection cycles can help reduce response times. The following tuning values aims to reduce malloc garbage collection cycles by setting it to a higher value. This may cause a slight increase in memory usage. You should monitor memory usage carefully to ensure your app is not running out of memory.
+          MSG
+          [LIMIT_ENV, LIMIT_MAX_ENV],
+          # Suggest to double the limit and max
+          [suggested_malloc_limit, suggested_malloc_limit_max],
+          [configured_malloc_limit, configured_malloc_limit_max],
+        )
+      end
+
+      def debug_state
+        {
+          given_suggestion: @given_suggestion,
+          minor_gc_count: minor_gc_count,
+          malloc_gc_count: malloc_gc_count,
+        }
+      end
+
+      private
+
+      def configured_malloc_limit
+        ENV[LIMIT_ENV]&.to_i
+      end
+
+      def configured_malloc_limit_max
+        ENV[LIMIT_MAX_ENV]&.to_i
+      end
+
+      def suggested_malloc_limit
+        if !configured_malloc_limit
+          DEFAULT_MALLOC_LIMIT * 2
+        elsif configured_malloc_limit < DEFAULT_MALLOC_LIMIT
+          DEFAULT_MALLOC_LIMIT
+        else
+          configured_malloc_limit * 2
+        end
+      end
+
+      def suggested_malloc_limit_max
+        if !configured_malloc_limit_max
+          DEFAULT_MALLOC_LIMIT_MAX * 2
+        elsif configured_malloc_limit_max < DEFAULT_MALLOC_LIMIT_MAX
+          DEFAULT_MALLOC_LIMIT_MAX
+        else
+          configured_malloc_limit_max * 2
+        end
+      end
+    end
+  end
+end

data/lib/autotuner/heuristic/oldmalloc.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Autotuner
+  module Heuristic
+    class Oldmalloc < Base
+      class << self
+        private
+
+        def supported?
+          true
+        end
+      end
+
+      OLDMALLOC_GC_RATIO_THRESHOLD = 0.01
+      MIN_OLDMALLOC_GC = 10
+
+      LIMIT_ENV = "RUBY_GC_OLDMALLOC_LIMIT"
+      LIMIT_MAX_ENV = "RUBY_GC_OLDMALLOC_LIMIT_MAX"
+
+      # Except for aggressively decreasing memory usage, it doesn't make sense
+      # for Rails apps to run oldmalloc major GC cycles. So we suggest an
+      # extremely high value (around 1TB here) to essentially disable it.
+      LIMIT_ENV_SUGGESTED_VALUE = 1_000_000_000_000
+      LIMIT_MAX_SUGGESTED_VALUE = 1_000_000_000_000
+
+      attr_reader :major_gc_count
+      attr_reader :oldmalloc_gc_count
+
+      def initialize(_system_context)
+        super
+
+        @major_gc_count = 0
+        @oldmalloc_gc_count = 0
+
+        @given_suggestion = false
+      end
+
+      def name
+        "Oldmalloc"
+      end
+
+      def call(request_context)
+        # major_by is only useful if we ran at least one major GC during the request
+        if request_context.after_gc_context.stat[:major_gc_count] ==
+            request_context.before_gc_context.stat[:major_gc_count]
+          return
+        end
+
+        # Technically, we could run more than one major GC in the request, but
+        # since we don't have information about the other major GC, we'll treat
+        # it as if there was only one major GC.
+        @major_gc_count += 1
+        @oldmalloc_gc_count += 1 if request_context.after_gc_context.latest_gc_info[:major_by] == :oldmalloc
+      end
+
+      def tuning_report
+        # Don't give suggestions twice
+        return if @given_suggestion
+        # Don't report if there's very few data points
+        return if @oldmalloc_gc_count < MIN_OLDMALLOC_GC
+
+        oldmalloc_gc_ratio = @oldmalloc_gc_count.to_f / @major_gc_count
+        # Don't report if there's very few oldmalloc GC
+        return if oldmalloc_gc_ratio <= OLDMALLOC_GC_RATIO_THRESHOLD
+
+        @given_suggestion = true
+
+        Report::MultipleEnvironmentVariables.new(
+          <<~MSG,
+            The following suggestions reduces the number of major garbage collection cycles, specifically a cycle called "oldmalloc". Your app runs oldmalloc cycles in approximately #{format("%.2f", oldmalloc_gc_ratio * 100)}% of all major garbage collection cycles.
+
+            Reducing major garbage collection cycles can help reduce response times, especially for the extremes (e.g. p95 or p99 response times). The following tuning values aims to disable oldmalloc garbage collection cycles by setting it to an extremely high value. This may cause a slight increase in memory usage. You should monitor memory usage carefully to ensure your app is not running out of memory.
+          MSG
+          [LIMIT_ENV, LIMIT_MAX_ENV],
+          [LIMIT_ENV_SUGGESTED_VALUE, LIMIT_MAX_SUGGESTED_VALUE],
+          [ENV[LIMIT_ENV]&.to_i, ENV[LIMIT_MAX_ENV]&.to_i],
+        )
+      end
+
+      def debug_state
+        {
+          given_suggestion: @given_suggestion,
+          major_gc_count: @major_gc_count,
+          oldmalloc_gc_count: @oldmalloc_gc_count,
+        }
+      end
+    end
+  end
+end