app_profiler 0.1.10 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 70f971ebae2492140483b90ada2f0d1daf33874803dcc4ea5404877093651974
-  data.tar.gz: df8395bf47f6e378f9322386a17c1934e9b38ac9269ea7ded80a721de7a5c4e9
+  metadata.gz: 1c36371d12c24dfed23e6e492b5c3912e01480bfd7a5973bf1f311a86adc86d3
+  data.tar.gz: 1b78da495c55cee24ab6b0d6f8d8194ca6cfb27030de7a4ba90db37fa60e3988
 SHA512:
-  metadata.gz: 2a10f138198666ddc840658e9599c05c40d4d2a14442b0cfa52df8776e00601fda95aaea871138656cdf2a05ae697966e30fbc62c3a1e5351b04987639a63b82
-  data.tar.gz: 2c6af888489015d1bcd827704a7710512455bd2c05d4e3aee596c32063d3b134049d592e5c0012d947e7f1f4731e8a55752303064f866cb535d8fb9ae06b91b9
+  metadata.gz: bd4e66293f491f25caba2a352b509012344bdc6e04c880cb4c3d60d00f3dc38cab50b9c59cf0cbe14c36adc2591610bd004addc28521cf077b7d3b7c91585947
+  data.tar.gz: 036c9de32a86b5e99e1d244fe1200aa3e0dabdf6d610d91c34aa6621bf8a194b9a769a8a9bae254432d2e2bfae67b137a1209c4214bb2c2ce774aa9db9bea907

data/lib/app_profiler/backend/base_backend.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  module Backend
+    class BaseBackend
+      def self.name
+        raise NotImplementedError
+      end
+
+      def run(params = {}, &block)
+        raise NotImplementedError
+      end
+
+      def start(params = {})
+        raise NotImplementedError
+      end
+
+      def stop
+        raise NotImplementedError
+      end
+
+      def results
+        raise NotImplementedError
+      end
+
+      def running?
+        raise NotImplementedError
+      end
+
+      class << self
+        def run_lock
+          @run_lock ||= Mutex.new
+        end
+      end
+
+      protected
+
+      def acquire_run_lock
+        self.class.run_lock.try_lock
+      end
+
+      def release_run_lock
+        self.class.run_lock.unlock
+      rescue ThreadError
+        AppProfiler.logger.warn("[AppProfiler] run lock not released as it was never acquired")
+      end
+    end
+  end
+end

data/lib/app_profiler/{profiler.rb → backend/stackprof_backend.rb}

@@ -3,13 +3,23 @@
 require "stackprof"
 
 module AppProfiler
-  module Profiler
-    DEFAULTS = {
-      mode: :cpu,
-      raw: true,
-    }.freeze
+  module Backend
+    class StackprofBackend < BaseBackend
+      DEFAULTS = {
+        mode: :cpu,
+        raw: true,
+      }.freeze
+
+      AVAILABLE_MODES = [
+        :wall,
+        :cpu,
+        :object,
+      ].freeze
+
+      def self.name
+        :stackprof
+      end
 
-    class << self
       def run(params = {})
         started = start(params)
 
@@ -27,6 +37,7 @@ module AppProfiler
       def start(params = {})
         # Do not start the profiler if StackProf was started somewhere else.
         return false if running?
+        return false unless acquire_run_lock
 
         clear
 
@@ -35,6 +46,7 @@ module AppProfiler
         AppProfiler.logger.info(
           "[Profiler] failed to start the profiler error_class=#{error.class} error_message=#{error.message}"
         )
+        release_run_lock
         # This is a boolean instead of nil because StackProf#start returns a
         # boolean as well.
         false
@@ -42,14 +54,16 @@ module AppProfiler
 
       def stop
         StackProf.stop
+      ensure
+        release_run_lock
       end
 
       def results
-        stackprof_profile = stackprof_results
+        stackprof_profile = backend_results
 
         return unless stackprof_profile
 
-        Profile.from_stackprof(stackprof_profile)
+        BaseProfile.from_stackprof(stackprof_profile)
       rescue => error
         AppProfiler.logger.info(
           "[Profiler] failed to obtain the profile error_class=#{error.class} error_message=#{error.message}"
@@ -57,9 +71,13 @@ module AppProfiler
         nil
       end
 
+      def running?
+        StackProf.running?
+      end
+
       private
 
-      def stackprof_results
+      def backend_results
         StackProf.results
       end
 
@@ -73,14 +91,8 @@ module AppProfiler
       # Ref: https://github.com/tmm1/stackprof/blob/0ded6c/ext/stackprof/stackprof.c#L118-L123
       #
       def clear
-        stackprof_results
-      end
-
-      def running?
-        StackProf.running?
+        backend_results
       end
     end
   end
-
-  private_constant :Profiler
 end

data/lib/app_profiler/backend/vernier_backend.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+gem("vernier", ">= 0.7.0")
+require "vernier"
+
+module AppProfiler
+  module Backend
+    class VernierBackend < BaseBackend
+      DEFAULTS = {
+        mode: :wall,
+      }.freeze
+
+      AVAILABLE_MODES = [
+        :wall,
+        :retained,
+      ].freeze
+
+      def self.name
+        :vernier
+      end
+
+      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 start(params = {})
+        # Do not start the profiler if we already have a collector started somewhere else.
+        return false if running?
+        return false unless acquire_run_lock
+
+        @mode = params.delete(:mode) || DEFAULTS[:mode]
+        raise ArgumentError unless AVAILABLE_MODES.include?(@mode)
+
+        @metadata = params.delete(:metadata)
+        clear
+
+        @collector ||= ::Vernier::Collector.new(@mode, **params)
+        @collector.start
+      rescue => error
+        AppProfiler.logger.info(
+          "[Profiler] failed to start the profiler error_class=#{error.class} error_message=#{error.message}"
+        )
+        release_run_lock
+        # This is a boolean instead of nil to be consistent with the stackprof backend behaviour
+        # boolean as well.
+        false
+      end
+
+      def stop
+        return false unless running?
+
+        @results = @collector&.stop
+        @collector = nil
+        !@results.nil?
+      ensure
+        release_run_lock
+      end
+
+      def results
+        vernier_profile = backend_results
+        clear
+
+        return unless vernier_profile
+
+        # HACK: - "data" is private, but we want to avoid serializing to JSON then
+        # parsing back from JSON by just directly getting the hash
+        data = ::Vernier::Output::Firefox.new(vernier_profile).send(:data)
+        data[:meta][:mode] = @mode # TODO: https://github.com/jhawthorn/vernier/issues/30
+        data[:meta].merge!(@metadata) if @metadata
+        @mode = nil
+        @metadata = nil
+
+        BaseProfile.from_vernier(data)
+      rescue => error
+        AppProfiler.logger.info(
+          "[Profiler] failed to obtain the profile error_class=#{error.class} error_message=#{error.message}"
+        )
+        nil
+      end
+
+      def running?
+        @collector != nil
+      end
+
+      private
+
+      def backend_results
+        @results
+      end
+
+      def clear
+        @results = nil
+      end
+    end
+  end
+end

data/lib/app_profiler/backend.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  module Backend
+    autoload :BaseBackend, "app_profiler/backend/base_backend"
+    autoload :StackprofBackend, "app_profiler/backend/stackprof_backend"
+    autoload :VernierBackend, "app_profiler/backend/vernier_backend"
+  end
+end

data/lib/app_profiler/middleware/base_action.rb

@@ -9,7 +9,7 @@ module AppProfiler
         end
 
         def cleanup
-          profile = Profiler.results
+          profile = AppProfiler.profiler.results
           call(profile) if profile
         end
       end

data/lib/app_profiler/middleware.rb

@@ -31,7 +31,7 @@ module AppProfiler
 
       return yield unless before_profile(env, params_hash)
 
-      profile = AppProfiler.run(params_hash) do
+      profile = AppProfiler.run(**params_hash) do
         response = yield
       end
 

data/lib/app_profiler/parameters.rb

@@ -4,17 +4,18 @@ require "rack"
 
 module AppProfiler
   class Parameters
-    DEFAULT_INTERVALS = { "cpu" => 1000, "wall" => 1000, "object" => 2000 }.freeze
-    MIN_INTERVALS = { "cpu" => 200, "wall" => 200, "object" => 400 }.freeze
-    MODES = DEFAULT_INTERVALS.keys.freeze
+    DEFAULT_INTERVALS = { "cpu" => 1000, "wall" => 1000, "object" => 2000, "retained" => 0 }.freeze
+    MIN_INTERVALS = { "cpu" => 200, "wall" => 200, "object" => 400, "retained" => 0 }.freeze
 
-    attr_reader :autoredirect, :async
+    attr_reader :autoredirect, :async, :backend
 
-    def initialize(mode: :wall, interval: nil, ignore_gc: false, autoredirect: false, async: false, metadata: {})
+    def initialize(mode: :wall, interval: nil, ignore_gc: false, autoredirect: false,
+      async: false, backend: nil, metadata: {})
       @mode = mode.to_sym
       @interval = [interval&.to_i || DEFAULT_INTERVALS.fetch(@mode.to_s), MIN_INTERVALS.fetch(@mode.to_s)].max
       @ignore_gc = !!ignore_gc
       @autoredirect = autoredirect
+      @backend = backend || AppProfiler::Backend::StackprofBackend.name
       @metadata = { context: AppProfiler.context }.merge(metadata)
       @async = async
     end
@@ -29,6 +30,7 @@ module AppProfiler
         interval: @interval,
         ignore_gc: @ignore_gc,
         metadata: @metadata,
+        backend: @backend,
       }
     end
   end

data/lib/app_profiler/profile/stackprof.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  class StackprofProfile < BaseProfile
+    FILE_EXTENSION = ".json"
+
+    def mode
+      @data[:mode]
+    end
+
+    def format
+      FILE_EXTENSION
+    end
+
+    def view(params = {})
+      AppProfiler.viewer.view(self, **params)
+    end
+  end
+end

data/lib/app_profiler/profile/vernier.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AppProfiler
+  class VernierProfile < BaseProfile
+    FILE_EXTENSION = ".gecko.json"
+
+    def mode
+      @data[:meta][:mode]
+    end
+
+    def format
+      FILE_EXTENSION
+    end
+
+    def view(params = {})
+      raise NotImplementedError
+    end
+  end
+end

data/lib/app_profiler/profile.rb

@@ -1,42 +1,45 @@
 # frozen_string_literal: true
 
+require "active_support/deprecation/constant_accessor"
+
 module AppProfiler
-  class Profile
+  autoload :StackprofProfile, "app_profiler/profile/stackprof"
+  autoload :VernierProfile, "app_profiler/profile/vernier"
+
+  class BaseProfile
     INTERNAL_METADATA_KEYS = [:id, :context]
     private_constant :INTERNAL_METADATA_KEYS
     class UnsafeFilename < StandardError; end
 
-    delegate    :[], to: :@data
     attr_reader :id, :context
 
+    delegate :[], to: :@data
+
     # 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|
+      StackprofProfile.new(data, **options).tap do |profile|
+        raise ArgumentError, "invalid profile data" unless profile.valid?
+      end
+    end
+
+    def self.from_vernier(data)
+      options = INTERNAL_METADATA_KEYS.map { |key| [key, data[:meta]&.delete(key)] }.to_h
+
+      VernierProfile.new(data, **options).tap do |profile|
         raise ArgumentError, "invalid profile data" unless profile.valid?
       end
     end
 
-    # `data` is assumed to be a Hash.
+    # `data` is assumed to be a Hash for Stackprof,
+    # a vernier "result" object for vernier
     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(params = {})
-      AppProfiler.viewer.view(self, **params)
-    end
-
     def upload
       AppProfiler.storage.upload(self).tap do |upload|
         if upload && defined?(upload.url)
@@ -60,6 +63,10 @@ module AppProfiler
       AppProfiler.storage.enqueue_upload(self)
     end
 
+    def valid?
+      mode.present?
+    end
+
     def file
       @file ||= path.tap do |p|
         p.dirname.mkpath
@@ -71,6 +78,18 @@ module AppProfiler
       @data
     end
 
+    def mode
+      raise NotImplementedError
+    end
+
+    def format
+      raise NotImplementedError
+    end
+
+    def view(params = {})
+      raise NotImplementedError
+    end
+
     private
 
     def path
@@ -79,11 +98,14 @@ module AppProfiler
         mode,
         id,
         Socket.gethostname,
-      ].compact.join("-") << ".json"
+      ].compact.join("-") << format
 
       raise UnsafeFilename if /[^0-9A-Za-z.\-\_]/.match?(filename)
 
       AppProfiler.profile_root.join(filename)
     end
   end
+
+  include ActiveSupport::Deprecation::DeprecatedConstantAccessor
+  deprecate_constant "Profile", "AppProfiler::BaseProfile", deprecator: ActiveSupport::Deprecation.new
 end

data/lib/app_profiler/railtie.rb

@@ -40,6 +40,7 @@ module AppProfiler
       AppProfiler.profile_enqueue_success = app.config.app_profiler.profile_enqueue_success
       AppProfiler.profile_enqueue_failure = app.config.app_profiler.profile_enqueue_failure
       AppProfiler.after_process_queue = app.config.app_profiler.after_process_queue
+      AppProfiler.backend = app.config.app_profiler.profiler_backend || :stackprof
     end
 
     initializer "app_profiler.add_middleware" do |app|

data/lib/app_profiler/request_parameters.rb

@@ -16,17 +16,30 @@ module AppProfiler
       query_param("async")
     end
 
+    def backend
+      backend = query_param("backend") || profile_header_param("backend") ||
+        AppProfiler.backend
+      backend.to_sym
+    end
+
     def valid?
       if mode.blank?
         return false
       end
 
-      unless Parameters::MODES.include?(mode)
-        AppProfiler.logger.info("[Profiler] unsupported profiling mode=#{mode}")
+      return false if backend != AppProfiler::Backend::StackprofBackend.name && !AppProfiler.vernier_supported?
+
+      if AppProfiler.vernier_supported? && backend == AppProfiler::Backend::VernierBackend.name &&
+          !AppProfiler::Backend::VernierBackend::AVAILABLE_MODES.include?(mode.to_sym)
+        AppProfiler.logger.info("[AppProfiler] unsupported profiling mode=#{mode} for backend #{backend}")
+        return false
+      elsif backend == AppProfiler::Backend::StackprofBackend.name &&
+          !AppProfiler::Backend::StackprofBackend::AVAILABLE_MODES.include?(mode.to_sym)
+        AppProfiler.logger.info("[AppProfiler] unsupported profiling mode=#{mode} for backend #{backend}")
         return false
       end
 
-      if interval.to_i < Parameters::MIN_INTERVALS[mode]
+      if interval.to_i < Parameters::MIN_INTERVALS[mode.to_s]
         return false
       end
 
@@ -38,6 +51,7 @@ module AppProfiler
         mode: mode.to_sym,
         interval: interval.to_i,
         ignore_gc: !!ignore_gc,
+        backend: backend,
         metadata: {
           id: request_id,
           context: context,
@@ -56,7 +70,7 @@ module AppProfiler
     end
 
     def interval
-      query_param("interval") || profile_header_param("interval") || Parameters::DEFAULT_INTERVALS[mode]
+      query_param("interval") || profile_header_param("interval") || Parameters::DEFAULT_INTERVALS[mode.to_s]
     end
 
     def request_id

data/lib/app_profiler/version.rb

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

data/lib/app_profiler.rb

@@ -9,6 +9,9 @@ module AppProfiler
   class ConfigurationError < StandardError
   end
 
+  class BackendError < StandardError
+  end
+
   DefaultProfileFormatter = proc do |upload|
     "#{AppProfiler.speedscope_host}#profileURL=#{upload.url}"
   end
@@ -32,8 +35,8 @@ module AppProfiler
   require "app_profiler/middleware"
   require "app_profiler/parameters"
   require "app_profiler/request_parameters"
-  require "app_profiler/profiler"
   require "app_profiler/profile"
+  require "app_profiler/backend"
   require "app_profiler/server"
 
   mattr_accessor :logger, default: Logger.new($stdout)
@@ -60,17 +63,73 @@ module AppProfiler
   mattr_reader :after_process_queue, default: nil
 
   class << self
-    def run(*args, &block)
-      Profiler.run(*args, &block)
+    def run(*args, backend: nil, **kwargs, &block)
+      orig_backend = self.backend
+      begin
+        self.backend = backend if backend
+        profiler.run(*args, **kwargs, &block)
+      rescue BackendError => e
+        logger.error(
+          "[AppProfiler.run] exception #{e} configuring backend #{backend}: #{e.message}"
+        )
+        yield
+      end
+    ensure
+      AppProfiler.backend = orig_backend
     end
 
     def start(*args)
-      Profiler.start(*args)
+      profiler.start(*args)
     end
 
     def stop
-      Profiler.stop
-      Profiler.results
+      profiler.stop
+      profiler.results
+    end
+
+    def running?
+      @backend&.running?
+    end
+
+    def profiler
+      backend
+      @backend ||= @profiler_backend.new
+    end
+
+    def backend=(new_backend)
+      return if new_backend == backend
+
+      new_profiler_backend = backend_for(new_backend)
+
+      if running?
+        raise BackendError,
+          "cannot change backend to #{new_backend} while #{backend} backend is running"
+      end
+
+      return if @profiler_backend == new_profiler_backend
+
+      clear
+      @profiler_backend = new_profiler_backend
+    end
+
+    def backend_for(backend_name)
+      if vernier_supported? &&
+          backend_name == AppProfiler::Backend::VernierBackend.name
+        AppProfiler::Backend::VernierBackend
+      elsif backend_name == AppProfiler::Backend::StackprofBackend.name
+        AppProfiler::Backend::StackprofBackend
+      else
+        raise BackendError, "unknown backend #{backend_name}"
+      end
+    end
+
+    def backend
+      @profiler_backend ||= Backend::StackprofBackend
+      @profiler_backend.name
+    end
+
+    def vernier_supported?
+      defined?(AppProfiler::Backend::VernierBackend.name)
     end
 
     def profile_header=(profile_header)
@@ -120,6 +179,13 @@ module AppProfiler
 
       AppProfiler.profile_url_formatter.call(upload)
     end
+
+    private
+
+    def clear
+      @backend.stop if @backend&.running?
+      @backend = nil
+    end
   end
 
   require "app_profiler/railtie" if defined?(Rails::Railtie)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: app_profiler
 version: !ruby/object:Gem::Version
-  version: 0.1.10
+  version: 0.2.0
 platform: ruby
 authors:
 - Gannon McGibbon
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-12-13 00:00:00.000000000 Z
+date: 2024-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -135,13 +135,18 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/app_profiler.rb
+- lib/app_profiler/backend.rb
+- lib/app_profiler/backend/base_backend.rb
+- lib/app_profiler/backend/stackprof_backend.rb
+- lib/app_profiler/backend/vernier_backend.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/parameters.rb
 - lib/app_profiler/profile.rb
-- lib/app_profiler/profiler.rb
+- lib/app_profiler/profile/stackprof.rb
+- lib/app_profiler/profile/vernier.rb
 - lib/app_profiler/railtie.rb
 - lib/app_profiler/request_parameters.rb
 - lib/app_profiler/server.rb
@@ -175,7 +180,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.22
+rubygems_version: 3.5.11
 signing_key: 
 specification_version: 4
 summary: Collect performance profiles for your Rails application.