app_profiler 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e14252a4cfb042174369c9a1db2b36944b69e9ea3a1c5deecda4eb6875b88c66
+  data.tar.gz: 10c8227518e0cf32755479fc231df4d676c08bdd0052c347372fde5d39a81f73
+SHA512:
+  metadata.gz: ad09ac71560705b5ccb548f9fab69c9c7ffa2d1183621ab7eb8faa51af73020b7efa3a9323db65b9a092f98e2e649d31641a92f5ac3d5433d3f8f2f298274b73
+  data.tar.gz: 95ddee7961e0a52829ea9bc31819c13b8bec3531f00a202cbd03532b11266f52c8c47c5171fed54c7bf55bbe19be4fb2664c08681d38f0229587166d2fa1d1ff

data/lib/app_profiler.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "app_profiler/version"
+require "app_profiler/railtie" if defined?(Rails::Railtie)
+
+module AppProfiler
+  class ConfigurationError < StandardError
+  end
+
+  module Storage
+    autoload :BaseStorage, "app_profiler/storage/base_storage"
+    autoload :FileStorage, "app_profiler/storage/file_storage"
+    autoload :GoogleCloudStorage, "app_profiler/storage/google_cloud_storage"
+  end
+
+  module Viewer
+    autoload :BaseViewer, "app_profiler/viewer/base_viewer"
+    autoload :SpeedscopeViewer, "app_profiler/viewer/speedscope_viewer"
+  end
+
+  autoload :Middleware, "app_profiler/middleware"
+  autoload :RequestParameters, "app_profiler/request_parameters"
+  autoload :Profiler, "app_profiler/profiler"
+  autoload :Profile, "app_profiler/profile"
+
+  mattr_accessor :logger
+  mattr_accessor :root
+  mattr_accessor :profile_root
+
+  mattr_accessor :speedscope_host, default: "https://speedscope.app"
+  mattr_accessor :autoredirect, default: false
+  mattr_reader   :profile_header, default: "X-Profile"
+  mattr_accessor :context, default: nil
+
+  mattr_accessor :storage, default: Storage::FileStorage
+  mattr_accessor :viewer, default: Viewer::SpeedscopeViewer
+  mattr_accessor :middleware, default: Middleware
+
+  class << self
+    def run(*args, &block)
+      Profiler.run(*args, &block)
+    end
+
+    def profile_header=(profile_header)
+      @@profile_header = profile_header # rubocop:disable Style/ClassVars
+      @@request_profile_header = nil    # rubocop:disable Style/ClassVars
+      @@profile_data_header = nil       # rubocop:disable Style/ClassVars
+    end
+
+    def request_profile_header
+      @@request_profile_header ||= begin # rubocop:disable Style/ClassVars
+        profile_header.upcase.gsub("-", "_").prepend("HTTP_")
+      end
+    end
+
+    def profile_data_header
+      @@profile_data_header ||= profile_header.dup << "-Data" # rubocop:disable Style/ClassVars
+    end
+  end
+end

data/lib/app_profiler/middleware.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "rack"
+require "app_profiler/middleware/base_action"
+require "app_profiler/middleware/upload_action"
+require "app_profiler/middleware/view_action"
+
+module AppProfiler
+  class Middleware
+    class_attribute :action,   default: UploadAction
+    class_attribute :disabled, default: false
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      profile(env) do
+        @app.call(env)
+      end
+    end
+
+    private
+
+    def profile(env)
+      params   = AppProfiler::RequestParameters.new(Rack::Request.new(env))
+      response = nil
+
+      return yield unless params.valid?
+
+      params_hash = params.to_h
+
+      return yield unless before_profile(env, params_hash)
+
+      profile = AppProfiler.run(params_hash) do
+        response = yield
+      end
+
+      return response unless profile && after_profile(env, profile)
+
+      action.call(
+        profile,
+        response: response,
+        autoredirect: params.autoredirect,
+      )
+
+      response
+    end
+
+    def before_profile(_env, _params)
+      true
+    end
+
+    def after_profile(_env, _profile)
+      true
+    end
+  end
+end

data/lib/app_profiler/middleware/base_action.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  class Middleware
+    class BaseAction
+      class << self
+        def call(_profile, _params = {})
+          raise NotImplementedError
+        end
+
+        def cleanup
+          profile = Profiler.results
+          call(profile) if profile
+        end
+      end
+    end
+  end
+end

data/lib/app_profiler/middleware/upload_action.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  class Middleware
+    class UploadAction < BaseAction
+      class << self
+        def call(profile, response: nil, autoredirect: nil)
+          profile_upload = profile.upload
+
+          return unless response
+
+          append_headers(
+            response,
+            upload: profile_upload,
+            autoredirect: autoredirect.nil? ? AppProfiler.autoredirect : autoredirect
+          )
+        end
+
+        private
+
+        def append_headers(response, upload:, autoredirect:)
+          return unless upload
+
+          response[1][profile_header]      = profile_url(upload)
+          response[1][profile_data_header] = profile_data_url(upload)
+
+          return unless autoredirect
+
+          # Automatically redirect to profile if autoredirect is true.
+          if response[0].to_i < 500
+            response[1]["Location"] = profile_url(upload)
+            response[0] = 303
+          end
+        end
+
+        def profile_url(upload)
+          "#{AppProfiler.speedscope_host}#profileURL=#{upload.url}"
+        end
+
+        def profile_data_url(upload)
+          upload.url
+        end
+
+        def profile_header
+          AppProfiler.profile_header
+        end
+
+        def profile_data_header
+          AppProfiler.profile_data_header
+        end
+      end
+    end
+  end
+end

data/lib/app_profiler/middleware/view_action.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  class Middleware
+    class ViewAction < BaseAction
+      class << self
+        def call(profile, _params = {})
+          profile.view
+        end
+      end
+    end
+  end
+end

data/lib/app_profiler/profile.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  class Profile
+    INTERNAL_METADATA_KEYS = %i(id context)
+    private_constant :INTERNAL_METADATA_KEYS
+
+    delegate    :[], to: :@data
+    attr_reader :id, :context
+
+    # This function should not be called if `StackProf.results` returns nil.
+    def self.from_stackprof(data)
+      options = INTERNAL_METADATA_KEYS.map { |key| [key, data[:metadata]&.delete(key)] }.to_h
+
+      new(data, **options).tap do |profile|
+        raise ArgumentError, "invalid profile data" unless profile.valid?
+      end
+    end
+
+    # `data` is assumed to be a Hash.
+    def initialize(data, id: nil, context: nil)
+      @id      = id.presence || SecureRandom.hex
+      @context = context
+      @data    = data
+    end
+
+    def valid?
+      mode.present?
+    end
+
+    def mode
+      @data[:mode]
+    end
+
+    def view
+      AppProfiler.viewer.view(self)
+    end
+
+    def upload
+      AppProfiler.storage.upload(self).tap do |upload|
+        if upload && defined?(upload.url)
+          AppProfiler.logger.info("[Profiler] uploaded profile profile_url=#{upload.url}")
+        end
+      end
+    rescue => error
+      AppProfiler.logger.info(
+        "[Profiler] failed to upload profile error_class=#{error.class} error_message=#{error.message}"
+      )
+      nil
+    end
+
+    def file
+      @file ||= path.tap do |p|
+        p.dirname.mkpath
+        p.write(JSON.dump(@data))
+      end
+    end
+
+    def to_h
+      @data
+    end
+
+    private
+
+    def path
+      filename = [
+        Time.zone.now.strftime("%Y%m%d-%H%M%S"),
+        mode,
+        id,
+        Socket.gethostname,
+      ].compact.join("-") << ".json"
+
+      AppProfiler.profile_root.join(filename)
+    end
+  end
+end

data/lib/app_profiler/profiler.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "stackprof"
+
+module AppProfiler
+  module Profiler
+    DEFAULTS = {
+      mode: :cpu,
+      raw: true,
+    }.freeze
+
+    class << self
+      def run(params = {})
+        started = start(params)
+
+        yield
+
+        return unless started
+
+        stop
+        results
+      ensure
+        # Only stop the profiler if profiling was started in this context.
+        stop if started
+      end
+
+      def results
+        stackprof_profile = stackprof_results
+
+        return unless stackprof_profile
+
+        Profile.from_stackprof(stackprof_profile)
+      rescue => error
+        AppProfiler.logger.info(
+          "[Profiler] failed to obtain the profile error_class=#{error.class} error_message=#{error.message}"
+        )
+        nil
+      end
+
+      private
+
+      def start(params = {})
+        # Do not start the profiler if StackProf was started somewhere else.
+        return false if running?
+
+        clear
+
+        StackProf.start(DEFAULTS.merge(params))
+      rescue => error
+        AppProfiler.logger.info(
+          "[Profiler] failed to start the profiler error_class=#{error.class} error_message=#{error.message}"
+        )
+        # This is a boolean instead of nil because StackProf#start returns a
+        # boolean as well.
+        false
+      end
+
+      def stop
+        StackProf.stop
+      end
+
+      def stackprof_results
+        StackProf.results
+      end
+
+      # Clears the previous profiling session.
+      #
+      # StackProf will attempt to reuse frames from the previous profiling
+      # session if the results are not collected. This is usually called before
+      # StackProf#start is invoked to ensure that new profiling sessions do
+      # not reuse previous frames if they exist.
+      #
+      # Ref: https://github.com/tmm1/stackprof/blob/0ded6c/ext/stackprof/stackprof.c#L118-L123
+      #
+      def clear
+        stackprof_results
+      end
+
+      def running?
+        StackProf.running?
+      end
+    end
+  end
+
+  private_constant :Profiler
+end

data/lib/app_profiler/railtie.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module AppProfiler
+  class Railtie < Rails::Railtie
+    config.app_profiler = ActiveSupport::OrderedOptions.new
+
+    initializer "app_profiler.configs" do |app|
+      AppProfiler.logger = app.config.app_profiler.logger || Rails.logger
+      AppProfiler.root = app.config.app_profiler.root || Rails.root
+      AppProfiler.storage = app.config.app_profiler.storage || Storage::FileStorage
+      AppProfiler.viewer = app.config.app_profiler.viewer || Viewer::SpeedscopeViewer
+      AppProfiler.storage.bucket_name = app.config.app_profiler.storage_bucket_name || "profiles"
+      AppProfiler.storage.credentials = app.config.app_profiler.storage_credentials || {}
+      AppProfiler.middleware = app.config.app_profiler.middleware || Middleware
+      AppProfiler.middleware.action = app.config.app_profiler.middleware_action || default_middleware_action
+      AppProfiler.middleware.disabled = app.config.app_profiler.middleware_disabled || false
+      AppProfiler.autoredirect = app.config.app_profiler.autoredirect || false
+      AppProfiler.speedscope_host = app.config.app_profiler.speedscope_host || ENV.fetch(
+        "APP_PROFILER_SPEEDSCOPE_URL", "https://speedscope.app"
+      )
+      AppProfiler.profile_header = app.config.app_profiler.profile_header || "X-Profile"
+      AppProfiler.profile_root = app.config.app_profiler.profile_root || Rails.root.join(
+        "tmp", "app_profiler"
+      )
+      AppProfiler.context = app.config.app_profiler.context || Rails.env
+    end
+
+    initializer "app_profiler.add_middleware" do |app|
+      unless AppProfiler.middleware.disabled
+        app.middleware.insert_before(0, AppProfiler.middleware)
+      end
+    end
+
+    private
+
+    def default_middleware_action
+      if Rails.env.development?
+        Middleware::ViewAction
+      else
+        Middleware::UploadAction
+      end
+    end
+  end
+end

data/lib/app_profiler/request_parameters.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "rack"
+
+module AppProfiler
+  class RequestParameters
+    DEFAULT_INTERVALS = { "cpu" => 1000, "wall" => 1000, "object" => 10000 }.freeze
+    MIN_INTERVALS = { "cpu" => 200, "wall" => 200, "object" => 10000 }.freeze
+    MODES = DEFAULT_INTERVALS.keys.freeze
+
+    def initialize(request)
+      @request = request
+    end
+
+    def autoredirect
+      query_param("autoredirect") || profile_header_param("autoredirect")
+    end
+
+    def valid?
+      if mode.blank?
+        return false
+      end
+
+      unless MODES.include?(mode)
+        AppProfiler.logger.info("[Profiler] unsupported profiling mode=#{mode}")
+        return false
+      end
+
+      if interval.to_i < MIN_INTERVALS[mode]
+        return false
+      end
+
+      true
+    end
+
+    def to_h
+      {
+        mode: mode.to_sym,
+        interval: interval.to_i,
+        metadata: {
+          id: request_id,
+          context: context,
+        },
+      }
+    end
+
+    private
+
+    def mode
+      query_param("profile") || profile_header_param("mode")
+    end
+
+    def interval
+      query_param("interval") || profile_header_param("interval") || DEFAULT_INTERVALS[mode]
+    end
+
+    def request_id
+      header("HTTP_X_REQUEST_ID")
+    end
+
+    def context
+      profile_header_param("context").presence || AppProfiler.context
+    end
+
+    def profile_header_param(name)
+      query_parser.parse_nested_query(header(profile_header), ";")[name]
+    rescue Rack::QueryParser::ParameterTypeError, RangeError
+      nil
+    end
+
+    def query_param(name)
+      @request.GET[name]
+    rescue Rack::QueryParser::ParameterTypeError, RangeError
+      nil
+    end
+
+    def header(name)
+      return unless @request.has_header?(name)
+      @request.get_header(name)
+    end
+
+    def query_parser
+      Rack::Utils.default_query_parser
+    end
+
+    def profile_header
+      AppProfiler.request_profile_header
+    end
+  end
+end

data/lib/app_profiler/storage/base_storage.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  module Storage
+    class BaseStorage
+      class_attribute :bucket_name, default: "profiles"
+      class_attribute :credentials, default: {}
+
+      def self.upload(_profile)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/app_profiler/storage/file_storage.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  module Storage
+    class FileStorage < BaseStorage
+      class Location
+        def initialize(file)
+          @file = file
+        end
+
+        def url
+          @file
+        end
+      end
+
+      class << self
+        def upload(profile)
+          Location.new(profile.file)
+        end
+      end
+    end
+  end
+end

data/lib/app_profiler/storage/google_cloud_storage.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+gem("google-cloud-storage", "~> 1.21")
+
+require "google/cloud/storage"
+require "active_support/notifications"
+require "zlib"
+
+module AppProfiler
+  module Storage
+    class GoogleCloudStorage < BaseStorage
+      GOOGLE_SCOPE = "https://www.googleapis.com/auth/devstorage.read_write"
+
+      class << self
+        def upload(profile, _params = {})
+          file = profile.file.open
+
+          ActiveSupport::Notifications.instrument(
+            "gcs_upload.app_profiler",
+            file_size: file.size,
+          ) do
+            bucket.create_file(
+              StringIO.new(gzipped_reader(file).read),
+              gcs_filename(profile),
+              content_type: "application/json",
+              content_encoding: "gzip",
+            )
+          end
+        end
+
+        private
+
+        def gcs_filename(profile)
+          File.join(profile.context.to_s, profile.file.basename)
+        end
+
+        def bucket
+          # The GCS gem requires the `storage.buckets.get`
+          # permission to retrieve bucket details. We will set `skip_lookup` to
+          # be true to skip this process.
+          @bucket ||= Google::Cloud::Storage.new(
+            credentials: credentials.presence,
+            scope: GOOGLE_SCOPE,
+            retries: 3,
+          ).bucket(bucket_name, skip_lookup: true)
+        end
+
+        # We could compress everything at once using `ActiveSupport::Gzip.compress`.
+        # Since we expect large files for profiles generated by stackprof,
+        # compressing in chunks avoids keeping all of them in memory.
+        def gzipped_reader(file)
+          reader, writer = IO.pipe(binmode: true)
+          Thread.new do
+            writer.set_encoding("binary")
+            gz = Zlib::GzipWriter.new(writer)
+            # Default chunk size for gzip is 16384.
+            gz.write(file.read(16384)) until file.eof?
+            gz.close
+          end
+          reader
+        end
+      end
+    end
+  end
+end

data/lib/app_profiler/version.rb

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

data/lib/app_profiler/viewer/base_viewer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  module Viewer
+    class BaseViewer
+      def self.view(_profile)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/app_profiler/viewer/speedscope_viewer.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  module Viewer
+    class SpeedscopeViewer < BaseViewer
+      mattr_accessor :yarn_setup, default: false
+
+      class YarnError < StandardError; end
+
+      class << self
+        def view(profile)
+          new(profile).view
+        end
+      end
+
+      def initialize(profile)
+        @profile = profile
+      end
+
+      def view
+        yarn("run speedscope \"#{@profile.file}\"")
+      end
+
+      private
+
+      def yarn(command)
+        setup_yarn unless yarn_setup
+        exec("yarn #{command}") do
+          raise YarnError, "Failed to run #{command}."
+        end
+      end
+
+      def setup_yarn
+        ensure_yarn_installed
+        yarn("init --yes") unless package_json_exists?
+        yarn("add --dev speedscope")
+      end
+
+      def ensure_yarn_installed
+        exec("which yarn > /dev/null") do
+          raise(
+            YarnError,
+            <<~MSG.squish
+              `yarn` command not found.
+              Please install `yarn` or make it available in PATH.
+            MSG
+          )
+        end
+        self.yarn_setup = true
+      end
+
+      def package_json_exists?
+        AppProfiler.root.join("package.json").exist?
+      end
+
+      def exec(command)
+        system(command).tap do |return_code|
+          yield unless return_code
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: app_profiler
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gannon McGibbon
+- Jay Ching Lim
+- João Júnior
+- Jon Simpson
+- Kevin Jalbert
+- Scott Francis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-02-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: stackprof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-stub-const
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: '0.6'
+description: 
+email:
+- gems@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/app_profiler.rb
+- lib/app_profiler/middleware.rb
+- lib/app_profiler/middleware/base_action.rb
+- lib/app_profiler/middleware/upload_action.rb
+- lib/app_profiler/middleware/view_action.rb
+- lib/app_profiler/profile.rb
+- lib/app_profiler/profiler.rb
+- lib/app_profiler/railtie.rb
+- lib/app_profiler/request_parameters.rb
+- lib/app_profiler/storage/base_storage.rb
+- lib/app_profiler/storage/file_storage.rb
+- lib/app_profiler/storage/google_cloud_storage.rb
+- lib/app_profiler/version.rb
+- lib/app_profiler/viewer/base_viewer.rb
+- lib/app_profiler/viewer/speedscope_viewer.rb
+homepage: https://github.com/Shopify/app_profiler
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Collect performance profiles for your Rails application.
+test_files: []