tunemygc 1.0.1

data/ext/tunemygc/tunemygc_ext.c

@@ -0,0 +1,156 @@
+#include "tunemygc_ext.h"
+
+VALUE rb_mTunemygc;
+static ID id_tunemygc_tracepoint;
+static ID id_tunemygc_raw_snapshot;
+
+static VALUE sym_gc_cycle_started;
+static VALUE sym_gc_cycle_ended;
+
+/* For 2.2.x incremental GC */
+#ifdef RUBY_INTERNAL_EVENT_GC_ENTER
+static VALUE sym_gc_cycle_entered;
+static VALUE sym_gc_cycle_exited;
+#endif
+
+/* From @tmm1/gctools */
+static double _tunemygc_walltime()
+{
+  struct timespec ts;
+#ifdef HAVE_CLOCK_GETTIME
+  if (clock_gettime(CLOCK_REALTIME, &ts) == -1) {
+    rb_sys_fail("clock_gettime");
+  }
+#else
+  {
+    struct timeval tv;
+    if (gettimeofday(&tv, 0) < 0) {
+      rb_sys_fail("gettimeofday");
+    }
+    ts.tv_sec = tv.tv_sec;
+    ts.tv_nsec = tv.tv_usec * 1000;
+  }
+#endif
+  return ts.tv_sec + ts.tv_nsec * 1e-9;
+}
+
+static VALUE tunemygc_walltime(VALUE mod)
+{
+    return DBL2NUM(_tunemygc_walltime());
+}
+
+/* Postponed job callback that fires when the VM is in a consistent state again (sometime
+ * after the GC cycle, notably RUBY_INTERNAL_EVENT_GC_END_SWEEP)
+ */
+static void tunemygc_invoke_gc_snapshot(void *data)
+{
+    tunemygc_stat_record *stat = (tunemygc_stat_record *)data;
+    VALUE snapshot = tunemygc_get_stat_record(stat);
+    rb_funcall(rb_mTunemygc, id_tunemygc_raw_snapshot, 1, snapshot);
+    free(stat);
+}
+
+/* GC tracepoint hook. Snapshots GC state using new low level helpers which are safe
+ * to call from within tracepoint handlers as they don't allocate and change the heap state
+ */
+static void tunemygc_gc_hook_i(VALUE tpval, void *data)
+{
+    rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+    rb_event_flag_t flag = rb_tracearg_event_flag(tparg);
+
+    tunemygc_stat_record *stat = ((tunemygc_stat_record*)malloc(sizeof(tunemygc_stat_record)));
+    stat->ts = _tunemygc_walltime();
+    stat->peak_rss = getPeakRSS();
+    stat->current_rss = getCurrentRSS();
+
+    switch (flag) {
+        case RUBY_INTERNAL_EVENT_GC_START:
+            stat->stage = sym_gc_cycle_started;
+            break;
+        case RUBY_INTERNAL_EVENT_GC_END_SWEEP:
+            stat->stage = sym_gc_cycle_ended;
+            break;
+#ifdef RUBY_INTERNAL_EVENT_GC_ENTER
+        case RUBY_INTERNAL_EVENT_GC_ENTER:
+            stat->stage = sym_gc_cycle_entered;
+            break;
+        case RUBY_INTERNAL_EVENT_GC_EXIT:
+            stat->stage = sym_gc_cycle_exited;
+            break;
+#endif
+    }
+
+    tunemygc_set_stat_record(stat);
+    rb_postponed_job_register(0, tunemygc_invoke_gc_snapshot, (void *)stat);
+}
+
+/* Installs the GC tracepoint and declare interest only in start of the cycle and end of sweep
+ * events
+ */
+static VALUE tunemygc_install_gc_tracepoint(VALUE mod)
+{
+    rb_event_flag_t events;
+    VALUE tunemygc_tracepoint = rb_ivar_get(rb_mTunemygc, id_tunemygc_tracepoint);
+    if (!NIL_P(tunemygc_tracepoint)) {
+        rb_tracepoint_disable(tunemygc_tracepoint);
+        rb_ivar_set(rb_mTunemygc, id_tunemygc_tracepoint, Qnil);
+    }
+    events = RUBY_INTERNAL_EVENT_GC_START | RUBY_INTERNAL_EVENT_GC_END_SWEEP;
+    tunemygc_tracepoint = rb_tracepoint_new(0, events, tunemygc_gc_hook_i, (void *)0);
+    if (NIL_P(tunemygc_tracepoint)) rb_warn("Could not install GC tracepoint!");
+    rb_tracepoint_enable(tunemygc_tracepoint);
+    rb_ivar_set(rb_mTunemygc, id_tunemygc_tracepoint, tunemygc_tracepoint);
+    return Qnil;
+}
+
+/* Removes a previously enabled GC tracepoint */
+static VALUE tunemygc_uninstall_gc_tracepoint(VALUE mod)
+{
+    VALUE tunemygc_tracepoint = rb_ivar_get(rb_mTunemygc, id_tunemygc_tracepoint);
+    if (!NIL_P(tunemygc_tracepoint)) {
+        rb_tracepoint_disable(tunemygc_tracepoint);
+        rb_ivar_set(rb_mTunemygc, id_tunemygc_tracepoint, Qnil);
+    }
+    return Qnil;
+}
+
+static VALUE tunemygc_peak_rss(VALUE mod)
+{
+    return SIZET2NUM(getPeakRSS());
+}
+
+static VALUE tunemygc_current_rss(VALUE mod)
+{
+    return SIZET2NUM(getCurrentRSS());
+}
+
+void Init_tunemygc_ext()
+{
+    /* Warm up the symbol table */
+    id_tunemygc_tracepoint = rb_intern("__tunemygc_tracepoint");
+    id_tunemygc_raw_snapshot = rb_intern("raw_snapshot");
+    rb_funcall(rb_mGC, rb_intern("stat"), 0);
+    rb_funcall(rb_mGC, rb_intern("latest_gc_info"), 0);
+
+    /* Symbol warmup */
+    sym_gc_cycle_started = ID2SYM(rb_intern("GC_CYCLE_STARTED"));
+    sym_gc_cycle_ended = ID2SYM(rb_intern("GC_CYCLE_ENDED"));
+
+    /* For 2.2.x incremental GC */
+#ifdef RUBY_INTERNAL_EVENT_GC_ENTER
+    sym_gc_cycle_entered = ID2SYM(rb_intern("GC_CYCLE_ENTERED"));
+    sym_gc_cycle_exited = ID2SYM(rb_intern("GC_CYCLE_EXITED"));
+#endif
+
+    tunemygc_setup_trace_symbols();
+
+    rb_mTunemygc = rb_define_module("TuneMyGc");
+    rb_ivar_set(rb_mTunemygc, id_tunemygc_tracepoint, Qnil);
+
+    rb_define_module_function(rb_mTunemygc, "install_gc_tracepoint", tunemygc_install_gc_tracepoint, 0);
+    rb_define_module_function(rb_mTunemygc, "uninstall_gc_tracepoint", tunemygc_uninstall_gc_tracepoint, 0);
+
+    rb_define_module_function(rb_mTunemygc, "walltime", tunemygc_walltime, 0);
+    rb_define_module_function(rb_mTunemygc, "peak_rss", tunemygc_peak_rss, 0);
+    rb_define_module_function(rb_mTunemygc, "current_rss", tunemygc_current_rss, 0);
+}

data/ext/tunemygc/tunemygc_ext.h

@@ -0,0 +1,21 @@
+#ifndef TUNEMYGC_EXT_H
+#define TUNEMYGC_EXT_H
+
+#include "ruby/ruby.h"
+#include "ruby/debug.h"
+
+extern VALUE rb_mTunemygc;
+
+#include <stddef.h>
+/* for walltime */
+#include <time.h>
+#include <sys/time.h>
+
+/* header we codegen'ed in extconf.rb from VM specific GC stats */
+#include "tunemygc_env.h"
+
+/* From getRSS.c */
+size_t getPeakRSS();
+size_t getCurrentRSS();
+
+#endif

data/lib/tunemygc/agent.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require "tunemygc/tunemygc_ext"
+require "tunemygc/interposer"
+require "tunemygc/snapshotter"
+require "logger"
+
+module TuneMyGc
+  MUTEX = Mutex.new
+
+  attr_accessor :logger, :interposer, :snapshotter
+
+  def snapshot(stage, timestamp = nil, meta = nil)
+    snapshotter.take(stage, timestamp, meta)
+  end
+
+  def raw_snapshot(snapshot)
+    snapshotter.take_raw(snapshot)
+  end
+
+  def log(message)
+    logger.info "[TuneMyGC] #{message}"
+  end
+
+  def reccommendations
+    MUTEX.synchronize do
+      require "tunemygc/syncer"
+      syncer = TuneMyGc::Syncer.new
+      config = syncer.sync(snapshotter)
+      require "tunemygc/configurator"
+      TuneMyGc::Configurator.new(config).configure
+    end
+  rescue Exception => e
+    log "Config reccommendation error (#{e.message})"
+  end
+
+  extend self
+
+  MUTEX.synchronize do
+    self.logger = Logger.new($stdout)
+    self.interposer = TuneMyGc::Interposer.new
+    self.snapshotter = TuneMyGc::Snapshotter.new
+  end
+end

data/lib/tunemygc/cli.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+require 'net/http'
+require 'certified'
+require 'timeout'
+require 'optparse'
+
+module TuneMyGc
+  class CLI
+    TIMEOUT = 10
+
+    attr_reader :uri, :client, :options
+
+    def self.start(args)
+      args = ["-h"] if args.empty?
+      options = {}
+      OptionParser.new do |opts|
+        opts.banner = "Usage: tunemygc [options]"
+
+        opts.on("-r ", "--register EMAIL", "Register this Rails app with the https://tunemygc.com service") do |email|
+          options[:email] = email
+        end
+        opts.on("-c ", "--config TOKEN", "Fetch the last known config for a given Rails app") do |token|
+          options[:config] = token
+        end
+        opts.on_tail("-h", "--help", "How to use the TuneMyGC agent CLI") do
+          puts opts
+          exit
+        end
+      end.parse!(args)
+      new(options)
+    end
+
+    def initialize(options)
+      @options = options
+      @uri = URI("http://#{TuneMyGc::HOST}")
+      @client = Net::HTTP.new(@uri.host, @uri.port)
+      @client.use_ssl = (uri.port == 443)
+      @client.read_timeout = TIMEOUT
+      register if options[:email]
+      fetch_config if options[:config]
+    end
+
+    def register
+      timeout do
+        registration = Net::HTTP::Post.new('/accounts')
+        registration.set_form_data(:email => options[:email])
+        response = client.request(registration)
+        if Net::HTTPUnprocessableEntity === response
+          puts "Registration error: #{response.body}"
+        elsif Net::HTTPSuccess === response
+          puts "Application registered. Use RUBY_GC_TOKEN=#{response.body} in your environment."
+        else
+          puts "Registration error: #{response.body}"
+        end
+      end
+    rescue Exception => e
+      puts "Registration error: #{e.inspect}"
+    end
+
+    def fetch_config
+      timeout do
+        config = Net::HTTP::Get.new("/apps/#{options[:config]}")
+        response = client.request(config)
+        if Net::HTTPNoContent === response
+          puts "There is no configuration for Rails app with token #{options[:config]} yet"
+        elsif Net::HTTPNotFound === response
+          puts "Rails app with token #{options[:config]} doesn't exist"
+        elsif Net::HTTPSuccess === response
+          puts "=== Suggested GC configuration:"
+          puts
+          puts response.body
+        else
+          puts "Config retrieval error: #{response.body}"
+        end
+      end
+    rescue Exception => e
+      puts "Config retrieval error: #{e.inspect}"
+    end
+
+    private
+    def timeout(&block)
+      Timeout.timeout(TIMEOUT + 1){ block.call }
+    end
+  end
+end

data/lib/tunemygc/configurator.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+module TuneMyGc
+  class Configurator
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+    end
+
+    def configure
+      if Hash === config && !config.empty?
+        TuneMyGc.log "==== Recommended GC configs from #{config.delete("callback")}"
+        write_env("Speed")
+      end
+    end
+
+    private
+    def write_env(strategy)
+      config.delete(strategy).each do |var,val|
+        TuneMyGc.log "export #{var}=#{val}"
+      end
+    end
+  end
+end

data/lib/tunemygc/interposer.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'active_support'
+require 'tunemygc/spies/action_controller'
+
+module TuneMyGc
+  class Interposer
+    attr_reader :spy
+    attr_accessor :installed
+
+    def initialize
+      reset
+    end
+
+    def on_initialized
+      GC.start(full_mark: true, :immediate_sweep => true)
+      TuneMyGc.install_gc_tracepoint
+      TuneMyGc.log "hooked: GC tracepoints"
+      TuneMyGc.snapshot(:BOOTED)
+
+      TuneMyGc.interposer.spy.install
+    end
+
+    def install
+      return if @installed
+      TuneMyGc.log "interposing"
+      ActiveSupport.on_load(:after_initialize) do
+        TuneMyGc.interposer.on_initialized
+      end
+      TuneMyGc.log "hooked: after_initialize"
+
+      at_exit do
+        if @installed
+          TuneMyGc.log "at_exit"
+          @spy.uninstall
+          TuneMyGc.snapshot(:TERMINATED)
+          TuneMyGc.reccommendations
+        end
+      end
+      TuneMyGc.log "hooked: at_exit"
+      @installed = true
+      TuneMyGc.log "interposed"
+    end
+
+    def check_uninstall
+      @spy.check_uninstall
+    end
+
+    def uninstall
+      @spy.uninstall
+      reset
+    end
+
+    private
+    def reset
+      @installed = false
+      @spy = TuneMyGc::Spies::ActionController.new
+    end
+  end
+end

data/lib/tunemygc/railtie.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'tunemygc/agent'
+require 'rails/railtie'
+
+module TuneMyGc
+  class Railtie < Rails::Railtie
+    initializer 'tunemygc' do
+      TuneMyGc.logger = Rails.logger
+      TuneMyGc.interposer.install
+    end
+  end
+end

data/lib/tunemygc/request_subscriber.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'tunemygc/subscriber'
+
+module TuneMyGc
+  class StartRequestSubscriber < Subscriber
+    def start(name, id, payload)
+      TuneMyGc.snapshot(:REQUEST_PROCESSING_STARTED)
+    end
+  end
+
+  class EndRequestSubscriber < Subscriber
+    def finish(name, id, payload)
+      TuneMyGc.snapshot(:REQUEST_PROCESSING_ENDED)
+      TuneMyGc.interposer.check_uninstall
+    end
+  end
+end

data/lib/tunemygc/snapshotter.rb

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'thread'
+
+module TuneMyGc
+  class Snapshotter
+    MAX_SAMPLES = 1000
+
+    attr_reader :buffer
+
+    def initialize(buf = Queue.new)
+      @buffer = buf
+    end
+
+    def take(stage, timestamp = nil, meta = nil)
+      _buffer([(timestamp || TuneMyGc.walltime), TuneMyGc.peak_rss, TuneMyGc.current_rss, stage, GC.stat, GC.latest_gc_info, meta])
+    end
+
+    # low level interface, for tests and GC callback
+    def take_raw(snapshot)
+      _buffer(snapshot)
+    end
+
+    def clear
+      @buffer.clear
+    end
+
+    def size
+      @buffer.size
+    end
+
+    def deq
+      @buffer.deq
+    end
+
+    def empty?
+      @buffer.empty?
+    end
+
+    private
+    def _buffer(snapshot)
+      if size < MAX_SAMPLES
+        @buffer << snapshot
+      else
+        TuneMyGc.log "Discarding snapshot #{snapshot.inspect} (max samples threshold of #{MAX_SAMPLES} reached)"
+      end
+    end
+  end
+end

data/lib/tunemygc/spies/action_controller.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'tunemygc/request_subscriber'
+
+module TuneMyGc
+  module Spies
+    class ActionController
+      attr_reader :subscriptions
+
+      def initialize
+        @subscriptions = []
+        @requests_processed = 0
+        @requests_limit = nil
+      end
+
+      def install
+        @subscriptions << ActiveSupport::Notifications.subscribe(/^start_processing.action_controller$/, TuneMyGc::StartRequestSubscriber.new)
+        TuneMyGc.log "hooked: start_processing.action_controller"
+
+        @subscriptions << ActiveSupport::Notifications.subscribe(/^process_action.action_controller$/, TuneMyGc::EndRequestSubscriber.new)
+        TuneMyGc.log "hooked: process_action.action_controller"
+      end
+
+      def uninstall
+        TuneMyGc.uninstall_gc_tracepoint
+        TuneMyGc.log "uninstalled GC tracepoint"
+        @subscriptions.each{|s| ActiveSupport::Notifications.unsubscribe(s) }
+        @subscriptions.clear
+        TuneMyGc.log "cleared ActiveSupport subscriptions"
+      end
+
+      def check_uninstall
+        if ENV["RUBY_GC_TUNE_REQUESTS"]
+          @requests_limit ||= Integer(ENV["RUBY_GC_TUNE_REQUESTS"])
+          @requests_processed += 1
+          if @requests_processed == @requests_limit
+            uninstall
+            TuneMyGc.log "kamikaze after #{@requests_processed} of #{@requests_limit} requests"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tunemygc/subscriber.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+module TuneMyGc
+  class Subscriber
+    def start(name, id, payload)
+    end
+
+    def finish(name, id, payload)
+    end
+
+    def publish(name, *args)
+    end
+  end
+end

data/lib/tunemygc/syncer.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+require 'net/http'
+require 'certified'
+require 'timeout'
+
+module TuneMyGc
+  class Syncer
+    TIMEOUT = 10 #seconds
+    ENVIRONMENT = [ENV['RUBY_GC_TOKEN'], RUBY_VERSION, Rails.version, ENV.select {|k,v| k =~ /RUBY_GC_/ }, TuneMyGc::VERSION, GC::OPTS, GC::INTERNAL_CONSTANTS].freeze
+
+    attr_reader :uri, :client
+
+    def initialize(host = TuneMyGc::HOST)
+      @uri = URI("http://#{host}/ruby")
+      @client = Net::HTTP.new(@uri.host, @uri.port)
+      @client.use_ssl = (uri.port == 443)
+      @client.read_timeout = TIMEOUT
+    end
+
+    def sync(snapshotter)
+      response = nil
+      timeout do
+        response = sync_with_tuner(snapshotter)
+      end
+      timeout do
+        process_config_callback(response)
+      end if response
+    end
+
+    private
+    def timeout(&block)
+      Timeout.timeout(TIMEOUT + 1){ block.call }
+    end
+
+    def sync_with_tuner(snapshotter)
+      snapshots = 0
+      # Fallback to Timeout if Net::HTTP read timeout fails
+      snapshots = snapshotter.size
+      TuneMyGc.log "Syncing #{snapshots} snapshots"
+      payload = [ENVIRONMENT]
+      debug = ENV["RUBY_GC_TUNE_DEBUG"]
+      TuneMyGc.log "=== Snapshots ===" if debug
+      while !snapshotter.empty?
+        snapshot = snapshotter.deq
+        TuneMyGc.log(snapshot) if debug
+        payload << snapshot
+      end
+      data = ActiveSupport::JSON.encode(payload)
+      response = client.post(uri.path, data, TuneMyGc::HEADERS)
+      if Net::HTTPNotFound === response
+        TuneMyGc.log "Invalid application token. Please generate one with 'bundle exec tunemygc <a_valid_email_address>' and set the RUBY_GC_TOKEN environment variable"
+        return false
+      elsif Net::HTTPNotImplemented === response
+        TuneMyGc.log "Ruby version #{RUBY_VERSION} or Rails version #{Rails.version} not supported. Failed to sync #{snapshots} snapshots"
+        return false
+      elsif Net::HTTPUpgradeRequired === response
+        TuneMyGc.log "Agent version #{response.body} required - please upgrade. Failed to sync #{snapshots} snapshots"
+        return false
+      elsif Net::HTTPPreconditionFailed === response
+        TuneMyGc.log "The GC is already tuned by environment variables (#{response.body}) - we respect that, doing nothing. Failed to sync #{snapshots} snapshots"
+        return false
+      elsif Net::HTTPBadRequest === response
+        TuneMyGc.log "Invalid payload (#{response.body}). Failed to sync #{snapshots} snapshots"
+        return false
+      elsif Net::HTTPInternalServerError === response
+        TuneMyGc.log "An internal error occurred (#{response.body}). Failed to sync #{snapshots} snapshots"
+        return false
+      elsif Net::HTTPSuccess === response
+        response
+      else
+        TuneMyGc.log "Unknown error: #{response.body}"
+        return false
+      end
+    rescue Exception => e
+      TuneMyGc.log "Failed to sync #{snapshots} snapshots (error: #{e})"
+      return false
+    ensure
+      # Prefer to loose data points than accumulate buffers indefinitely on error or other conditions
+      snapshotter.clear
+    end
+
+    def process_config_callback(response)
+      config = client.get(URI(response.body).path)
+      ActiveSupport::JSON.decode(config.body).merge('callback' => response.body)
+    rescue Exception => e
+      TuneMyGc.log "Failed to process config callback url #{response.body} (error: #{e})"
+      return false
+    end
+  end
+end

data/lib/tunemygc/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+
+module TuneMyGc
+  VERSION = "1.0.1"
+end

data/lib/tunemygc.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+tunemygc_min_ruby_version = "2.1.0"
+
+if RUBY_VERSION >= tunemygc_min_ruby_version
+  require "tunemygc/version" unless defined? TuneMyGc::VERSION
+
+  module TuneMyGc
+    HOST = (ENV['RUBY_GC_TUNE_HOST'] || "tunemygc.com:443").freeze
+    HEADERS = { "Content-Type" => "application/json",
+                "Accept" => "application/json",
+                "User-Agent" => "TuneMyGC #{TuneMyGc::VERSION}"}.freeze
+  end
+
+  if ENV["RUBY_GC_TUNE"] && defined?(Rails) && Rails.version >= "4.0"
+    require 'tunemygc/railtie'
+  else
+    puts "[TuneMyGC] not enabled"
+  end
+else
+  puts "[TuneMyGC] requires a Ruby version #{tunemygc_min_ruby_version} or newer"
+end

data/test/fixtures.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+
+require 'time'
+
+module Fixtures
+  STAGE_BOOTED = [1420152606.1162581, "BOOTED", {"count"=>32, "heap_used"=>950, "heap_length"=>1519, "heap_increment"=>569, "heap_live_slot"=>385225, "heap_free_slot"=>2014, "heap_final_slot"=>0, "heap_swept_slot"=>101119, "heap_eden_page_length"=>950, "heap_tomb_page_length"=>0, "total_allocated_object"=>2184137, "total_freed_object"=>1798912, "malloc_increase"=>9665288, "malloc_limit"=>16777216, "minor_gc_count"=>26, "major_gc_count"=>6, "remembered_shady_object"=>5145, "remembered_shady_object_limit"=>6032, "old_object"=>230164, "old_object_limit"=>301030, "oldmalloc_increase"=>11715304, "oldmalloc_limit"=>24159190}, {"major_by"=>nil, "gc_by"=>"newobj", "have_finalizer"=>false, "immediate_sweep"=>false}, nil]
+
+  CONFIG = {"Memory"=>{"RUBY_GC_HEAP_INIT_SLOTS"=>307562,"RUBY_GC_HEAP_FREE_SLOTS"=>6151,"RUBY_GC_HEAP_GROWTH_FACTOR"=>0.07,"RUBY_GC_HEAP_GROWTH_MAX_SLOTS"=>6151,"RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR"=>0.11,"RUBY_GC_MALLOC_LIMIT"=>2000000,"RUBY_GC_MALLOC_LIMIT_MAX"=>4000000,"RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR"=>0.11,"RUBY_GC_OLDMALLOC_LIMIT"=>2000000,"RUBY_GC_OLDMALLOC_LIMIT_MAX"=>4000000,"RUBY_GC_OLDMALLOC_LIMIT_GROWTH_FACTOR"=>0.11},"Speed"=>{"RUBY_GC_HEAP_INIT_SLOTS"=>369074,"RUBY_GC_HEAP_FREE_SLOTS"=>184537,"RUBY_GC_HEAP_GROWTH_FACTOR"=>1.2,"RUBY_GC_HEAP_GROWTH_MAX_SLOTS"=>123024,"RUBY_GC_HEAP_OLDOBJECT_LIMIT_FACTOR"=>2.0,"RUBY_GC_MALLOC_LIMIT"=>64000000,"RUBY_GC_MALLOC_LIMIT_MAX"=>128000000,"RUBY_GC_MALLOC_LIMIT_GROWTH_FACTOR"=>1.2,"RUBY_GC_OLDMALLOC_LIMIT"=>64000000,"RUBY_GC_OLDMALLOC_LIMIT_MAX"=>128000000,"RUBY_GC_OLDMALLOC_LIMIT_GROWTH_FACTOR"=>1.2}, "callback"=>"https://tunemygc.com/configs/8d07e13cc5a7bba2da3510b9ca5e75f4.json"}
+end