scout_apm 3.0.0.pre10 → 3.0.0.pre11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1bbc487af5636f30f5768e6bae7e8656c24811b
-  data.tar.gz: 9e130174afe2ca2c2fb4764b7bc2bfa483ad95e5
+  metadata.gz: 36bac9cf47e89f5cec6475b574b6cd948339d627
+  data.tar.gz: dd2bc23001811e393950d502f04b2a359dae083d
 SHA512:
-  metadata.gz: 49a9d4dc629b9fa48ae63a0f4cefe67ce1eb4a5328213b83b194dfcc4ee745445d72e931ef665ffe78d2f66630e866a10815297b62d89a9e52b56361754990d8
-  data.tar.gz: c2d3469fa72ce16635ef964b0ed3c2e96e8fcdc2c006414ce098ccee9ec3cb1d4dac5ae3ad02de714b3b563e28dbd05a08e1da9c79fe08290f32beb52f9656c3
+  metadata.gz: 0d2e5b8270afe767d63890df65b8ea6f1fba96f4a2187cd58537372e13c7555f94875b3884473f210eb6e96f1815240508a53c50638e0ba74ad96075d9364888
+  data.tar.gz: 7b0169e3e311061dc20da5088f7b22247ec3acf66ba145b827a926ef87763bf6e576282a282611c2d5178412de7b8ade5a24a7c50e730399c560e1f846626020

data/.gitignore

@@ -18,3 +18,4 @@ coverage/*
 lib/*.bundle
 lib/*.so
 **/.RUBYARCHDIR.time
+log/scout_apm.log

data/CHANGELOG.markdown

@@ -1,6 +1,52 @@
+<<<<<<< HEAD
 # 3.0.0
 
 * ScoutProf BETA
+=======
+# 2.1.32
+
+* Better naming when using Resque + ActiveJob
+* Better naming when using Sidekiq + DelayedExtension
+>>>>>>> master
+
+# 2.1.31
+
+* Better detection of Resque queue names
+* Fix passing arguments through Active Record instrumentation. (Thanks to Nick Quaranto for providing the fix)
+* Stricter checks to prevent agent from starting in Rails console
+
+# 2.1.30
+
+* Add Resque support.
+
+# 2.1.29
+
+* Add `scm_subdirectory` option. Useful for when your app code does not live in your SCM root directory.
+
+# 2.1.28
+
+* Changes to app server load data
+
+# 2.1.27
+
+* Don't attempt to call `current_layer.type` on nil
+
+# 2.1.26
+
+* Bug fix [4b188d6](https://github.com/scoutapp/scout_apm_ruby/commit/4b188d698852c86b86d8768ea5b37d706ce544fe)
+
+# 2.1.25
+
+* Automatically instrument API and Metal controllers.
+
+# 2.1.24
+
+* Capture additional layers of application backtrace frames. (From 3 -> 8)
+
+# 2.1.23
+
+* Extend Mongoid instrumentation to 6.x
+>>>>>>> master
 
 # 2.1.22
 
@@ -66,6 +112,7 @@
 # 2.1.9
 
 * Send raw histograms of response time, enabling more accurate 95th %iles
+* Raw histograms are used in Apdex calculations
 * Gzip payloads
 * Fix Mongoid (5.0) + Mongo (2.1) support
 * Initial Delayed Job support

data/Guardfile

@@ -0,0 +1,42 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?test_(.*)\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+
+  # with Minitest::Spec
+  # watch(%r{^spec/(.*)_spec\.rb$})
+  # watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+
+  # Rails 4
+  # watch(%r{^app/(.+)\.rb$})                               { |m| "test/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/application_controller\.rb$}) { 'test/controllers' }
+  # watch(%r{^app/controllers/(.+)_controller\.rb$})        { |m| "test/integration/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)_mailer/.+})                    { |m| "test/mailers/#{m[1]}_mailer_test.rb" }
+  # watch(%r{^lib/(.+)\.rb$})                               { |m| "test/lib/#{m[1]}_test.rb" }
+  # watch(%r{^test/.+_test\.rb$})
+  # watch(%r{^test/test_helper\.rb$}) { 'test' }
+
+  # Rails < 4
+  # watch(%r{^app/controllers/(.*)\.rb$}) { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r{^app/helpers/(.*)\.rb$})     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r{^app/models/(.*)\.rb$})      { |m| "test/unit/#{m[1]}_test.rb" }
+end

data/lib/scout_apm.rb

@@ -15,6 +15,7 @@ require 'thread'
 require 'time'
 require 'yaml'
 require 'rbconfig'
+require 'webrick'
 
 #####################################
 # Gem Requires
@@ -54,6 +55,7 @@ require 'scout_apm/server_integrations/null'
 
 require 'scout_apm/background_job_integrations/sidekiq'
 require 'scout_apm/background_job_integrations/delayed_job'
+require 'scout_apm/background_job_integrations/resque'
 
 require 'scout_apm/framework_integrations/rails_2'
 require 'scout_apm/framework_integrations/rails_3_or_4'
@@ -84,6 +86,7 @@ require 'scout_apm/instruments/sinatra'
 require 'scout_apm/instruments/process/process_cpu'
 require 'scout_apm/instruments/process/process_memory'
 require 'scout_apm/instruments/percentile_sampler'
+require 'scout_apm/instruments/action_view'
 require 'allocations'
 
 begin
@@ -100,6 +103,7 @@ require 'scout_apm/utils/backtrace_parser'
 require 'scout_apm/utils/installed_gems'
 require 'scout_apm/utils/klass_helper'
 require 'scout_apm/utils/null_logger'
+require 'scout_apm/utils/scm'
 require 'scout_apm/utils/sql_sanitizer'
 require 'scout_apm/utils/time'
 require 'scout_apm/utils/unique_id'
@@ -124,6 +128,8 @@ require 'scout_apm/tracer'
 require 'scout_apm/context'
 require 'scout_apm/instant_reporting'
 require 'scout_apm/trace_compactor'
+require 'scout_apm/background_recorder'
+require 'scout_apm/synchronous_recorder'
 
 require 'scout_apm/metric_meta'
 require 'scout_apm/metric_stats'
@@ -151,6 +157,14 @@ require 'scout_apm/middleware'
 
 require 'scout_apm/instant/middleware'
 
+require 'scout_apm/rack'
+
+require 'scout_apm/remote/server'
+require 'scout_apm/remote/router'
+require 'scout_apm/remote/message'
+require 'scout_apm/remote/recorder'
+require 'scout_apm/instruments/resque'
+
 if defined?(Rails) && defined?(Rails::VERSION) && defined?(Rails::VERSION::MAJOR) && Rails::VERSION::MAJOR >= 3 && defined?(Rails::Railtie)
   module ScoutApm
     class Railtie < Rails::Railtie

data/lib/scout_apm/agent.rb

@@ -10,6 +10,7 @@ module ScoutApm
 
     # Accessors below are for associated classes
     attr_accessor :store
+    attr_reader :recorder
     attr_accessor :layaway
     attr_accessor :config
     attr_accessor :logger
@@ -41,6 +42,9 @@ module ScoutApm
       @process_start_time = Time.now
       @options ||= options
 
+      # until the agent is started, there's no recorder
+      @recorder = nil
+
       # Start up without attempting to load a configuration file. We need to be
       # able to lookup configuration options like "application_root" which would
       # then in turn influence where the configuration file came from.
@@ -54,6 +58,7 @@ module ScoutApm
       @request_histograms_by_time = Hash.new { |h, k| h[k] = ScoutApm::RequestHistograms.new }
 
       @store          = ScoutApm::Store.new
+
       @layaway        = ScoutApm::Layaway.new(config, environment)
       @metric_lookup  = Hash.new
 
@@ -84,6 +89,11 @@ module ScoutApm
         return false unless force?
       end
 
+      if environment.interactive?
+        logger.warn "Agent attempting to load in interactive mode. #{force? ? 'Forcing agent to start' : 'Not starting agent'}"
+        return false unless force?
+      end
+
       if app_server_missing?(options) && background_job_missing?
         if force?
           logger.warn "Agent starting (forced)"
@@ -111,13 +121,14 @@ module ScoutApm
     def start(options = {})
       @options.merge!(options)
 
-
       @config = ScoutApm::Config.with_file(@config.value("config_file"))
       layaway.config = config
 
       init_logger
       logger.info "Attempting to start Scout Agent [#{ScoutApm::VERSION}] on [#{environment.hostname}]"
 
+      @recorder = create_recorder
+
       @config.log_settings
 
       @ignored_uris = ScoutApm::IgnoredUris.new(config.value('ignore'))
@@ -262,6 +273,9 @@ module ScoutApm
         ScoutApm::Instruments::Stacks.start
       end
 
+      @recorder = create_recorder
+      logger.info("recorder is now: #{@recorder.class}")
+
       @background_worker = ScoutApm::BackgroundWorker.new
       @background_worker_thread = Thread.new do
         @background_worker.start {
@@ -303,6 +317,7 @@ module ScoutApm
         end
       end
 
+      install_instrument(ScoutApm::Instruments::ActionView)
       install_instrument(ScoutApm::Instruments::ActiveRecord)
       install_instrument(ScoutApm::Instruments::Moped)
       install_instrument(ScoutApm::Instruments::Mongoid)
@@ -341,5 +356,47 @@ module ScoutApm
     def background_job_missing?(options = {})
       environment.background_job_integration.nil? && !options[:skip_background_job_check]
     end
+
+    def clear_recorder
+      @recorder = nil
+    end
+
+    def create_recorder
+      if @recorder
+        return @recorder
+      end
+
+      if config.value("async_recording")
+        logger.debug("Using asynchronous recording")
+        ScoutApm::BackgroundRecorder.new(logger).start
+      else
+        logger.debug("Using synchronous recording")
+        ScoutApm::SynchronousRecorder.new(logger).start
+      end
+    end
+
+    def start_remote_server(bind, port)
+      return if @remote_server && @remote_server.running?
+
+      logger.info("Starting Remote Agent Server")
+
+      # Start the listening web server only in parent process.
+      @remote_server = ScoutApm::Remote::Server.new(
+        bind,
+        port,
+        ScoutApm::Remote::Router.new(ScoutApm::SynchronousRecorder.new(logger), logger),
+        logger
+      )
+
+      @remote_server.start
+    end
+
+    # Execute this in the child process of a remote agent. The parent is
+    # expected to have its accepting webserver up and running
+    def use_remote_recorder(host, port)
+      logger.debug("Becoming Remote Agent (reporting to: #{host}:#{port})")
+      @recorder = ScoutApm::Remote::Recorder.new(host, port, logger)
+      @store = ScoutApm::FakeStore.new
+    end
   end
 end

data/lib/scout_apm/agent/logging.rb

@@ -6,7 +6,12 @@ module ScoutApm
         "#{environment.root}/log"
       end
 
-      def init_logger
+      def init_logger(opts={})
+        if opts[:force]
+          @log_file = nil
+          @logger = nil
+        end
+
         begin
           @log_file ||= determine_log_destination
         rescue => e

data/lib/scout_apm/app_server_load.rb

@@ -27,20 +27,30 @@ module ScoutApm
     end
 
     def data
-      { :server_time        => Time.now,
-        :framework          => ScoutApm::Environment.instance.framework_integration.human_name,
-        :framework_version  => ScoutApm::Environment.instance.framework_integration.version,
-        :environment        => ScoutApm::Environment.instance.framework_integration.env,
-        :app_server         => ScoutApm::Environment.instance.app_server,
+      { :server_time        => to_s_safe(Time.now),
+        :framework          => to_s_safe(ScoutApm::Environment.instance.framework_integration.human_name),
+        :framework_version  => to_s_safe(ScoutApm::Environment.instance.framework_integration.version),
+        :environment        => to_s_safe(ScoutApm::Environment.instance.framework_integration.env),
+        :app_server         => to_s_safe(ScoutApm::Environment.instance.app_server),
         :ruby_version       => RUBY_VERSION,
-        :hostname           => ScoutApm::Environment.instance.hostname,
-        :database_engine    => ScoutApm::Environment.instance.database_engine,      # Detected
-        :database_adapter   => ScoutApm::Environment.instance.raw_database_adapter, # Raw
-        :application_name   => ScoutApm::Environment.instance.application_name,
+        :hostname           => to_s_safe(ScoutApm::Environment.instance.hostname),
+        :database_engine    => to_s_safe(ScoutApm::Environment.instance.database_engine),      # Detected
+        :database_adapter   => to_s_safe(ScoutApm::Environment.instance.raw_database_adapter), # Raw
+        :application_name   => to_s_safe(ScoutApm::Environment.instance.application_name),
         :libraries          => ScoutApm::Utils::InstalledGems.new.run,
-        :paas               => ScoutApm::Environment.instance.platform_integration.name,
-        :git_sha            => ScoutApm::Environment.instance.git_revision.sha
+        :paas               => to_s_safe(ScoutApm::Environment.instance.platform_integration.name),
+        :git_sha            => to_s_safe(ScoutApm::Environment.instance.git_revision.sha)
       }
     end
+
+    # Calls `.to_s` on the object passed in.
+    # Returns literal string 'to_s error' if the object does not respond to .to_s
+    def to_s_safe(obj)
+      if obj.respond_to?(:to_s)
+        obj.to_s
+      else
+        'to_s error'
+      end
+    end
   end
 end

data/lib/scout_apm/background_job_integrations/resque.rb

@@ -0,0 +1,85 @@
+module ScoutApm
+  module BackgroundJobIntegrations
+    class Resque
+      def name
+        :resque
+      end
+
+      def present?
+        defined?(::Resque) &&
+          ::Resque.respond_to?(:before_first_fork) &&
+          ::Resque.respond_to?(:after_fork)
+      end
+
+      # Lies. This forks really aggressively, but we have to do handling
+      # of it manually here, rather than via any sort of automatic
+      # background worker starting
+      def forking?
+        false
+      end
+
+      def install
+        install_before_fork
+        install_after_fork
+      end
+
+      def install_before_fork
+        ::Resque.before_first_fork do
+          begin
+            ScoutApm::Agent.instance.start(:skip_app_server_check => true)
+            ScoutApm::Agent.instance.start_background_worker
+            ScoutApm::Agent.instance.start_remote_server(bind, port)
+          rescue Errno::EADDRINUSE
+            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque Instruments, Port #{port} already in use. Set via the `remote_agent_port` configuration option"
+          rescue => e
+            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque before_first_fork: #{e.inspect}"
+          end
+        end
+      end
+
+      def install_after_fork
+        ::Resque.after_fork do
+          begin
+            ScoutApm::Agent.instance.use_remote_recorder(bind, port)
+            inject_job_instrument
+          rescue => e
+            ScoutApm::Agent.instance.logger.warn "Error while Installing Resque after_fork: #{e.inspect}"
+          end
+        end
+      end
+
+      # Insert ourselves into the point when resque turns a string "TestJob"
+      # into the class constant TestJob, and insert our instrumentation plugin
+      # into that constantized class
+      #
+      # This automates away any need for the user to insert our instrumentation into
+      # each of their jobs
+      def inject_job_instrument
+        ::Resque::Job.class_eval do
+          def payload_class_with_scout_instruments
+            klass = payload_class_without_scout_instruments
+            klass.extend(ScoutApm::Instruments::Resque)
+            klass
+          end
+          alias_method :payload_class_without_scout_instruments, :payload_class
+          alias_method :payload_class, :payload_class_with_scout_instruments
+        end
+      end
+
+      private
+
+      def bind
+        config.value("remote_agent_host")
+      end
+
+      def port
+        config.value("remote_agent_port")
+      end
+
+      def config
+        @config || ScoutApm::Agent.instance.config
+      end
+    end
+  end
+end
+

data/lib/scout_apm/background_job_integrations/sidekiq.rb

@@ -55,8 +55,6 @@ module ScoutApm
     # We insert this middleware into the Sidekiq stack, to capture each job,
     # and time them.
     class SidekiqMiddleware
-      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper'.freeze
-
       def call(_worker, msg, queue)
         req = ScoutApm::RequestManager.lookup
         req.job!
@@ -89,12 +87,30 @@ module ScoutApm
       end
 
       UNKNOWN_CLASS_PLACEHOLDER = 'UnknownJob'.freeze
+      ACTIVE_JOB_KLASS = 'ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper'.freeze
+      DELAYED_WRAPPER_KLASS = 'Sidekiq::Extensions::DelayedClass'.freeze
+
 
       def job_class(msg)
         job_class = msg.fetch('class', UNKNOWN_CLASS_PLACEHOLDER)
+
         if job_class == ACTIVE_JOB_KLASS && msg.key?('wrapped')
-          job_class = msg['wrapped']
+          begin
+            job_class = msg['wrapped']
+          rescue
+            ACTIVE_JOB_KLASS
+          end
+        elsif job_class == DELAYED_WRAPPER_KLASS
+          begin
+            yml = msg['args'].first
+            deserialized_args = YAML.load(yml)
+            klass, method, *rest = deserialized_args
+            job_class = [klass,method].map(&:to_s).join(".")
+          rescue
+            DELAYED_WRAPPER_KLASS
+          end
         end
+
         job_class
       rescue
         UNKNOWN_CLASS_PLACEHOLDER