scout_apm 1.6.8 → 2.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 60e5f3ca394fce2b63871b71be1225d9634687aa
-  data.tar.gz: 330e89e41635be1c597179faaca221af76ccbd2e
+  metadata.gz: b18724905e7c795caad3fc416688b3044e624d79
+  data.tar.gz: ee4ec99aeb9fa9e32c7b846caec0f010070546c2
 SHA512:
-  metadata.gz: 0d9aa3156586ae561fd952135e0974157ae2d33347d772db695fd1d7519109a0fc2b6ae663163930d76c5f701c8282357fd70c7694299bafa53092369ff61b6c
-  data.tar.gz: 189eba2d8cafd88043b09665e82a73560b3e53a418b3846b8f796d4e80f895a1e2082e8cb5e5bf43d8ec0eb8aef0e39b5c19649d6445700596e0509c88cda41c
+  metadata.gz: 236bfd93df93733c409684ac735dfbc77b5412f221127b5acbec9fc679b3141c6ac8e4c46c485295532aee7821b8fda36edd648233f820ed045d667905237448
+  data.tar.gz: 4b43e6158568bd089b3174bd8af445baef2260f92a33c31b50ed8627722a9f194fc2e4352c509c12e677e71f824e04e22226ce5c1b7a5c542f2e806167c0aabb

data/.gitignore

@@ -5,6 +5,13 @@ Gemfile.lock
 pkg/*
 .rvmrc
 .idea
+test/tmp/*
+/tmp
+/ext/stack_profile/stack_profile.bundle
+/ext/stack_profile/stack_profile.so
+/ext/stack_profile/stack_profile.o
+/ext/stack_profile/mkmf.log
+/ext/stack_profile/Makefile
+.DS_Store
 test/tmp/*coverage/*
 coverage/*
-lib/*.bundle

data/CHANGELOG.markdown

@@ -1,67 +1,17 @@
-# 1.6.8
+# 2.0.0
 
-* Don't wait on a sleeping thread during shutdown
-
-# 1.6.7
-
-* Mongoid bugfixes
-
-# 1.6.6
-
-* Bugfix related to DB detection
-
-# 1.6.5
-
-* Add Mongoid 5.x support
-* Fix autodetection of mysql databases
-
-# 1.6.4
-
-* Add Grape instrumentation
-* Handle DATABASE_URL configurations better
-* Change default (undeteced) database to Postgres (was Mysql)
-
-# 1.6.3
-
-* Handle nil ignore_traces when ignoring trace patterns
-
-# 1.6.2
-
-* Use a more flexible approach to storing "Layaway Files" (the temporary data
-  files the agent uses).
-
-# 1.6.1
-
-* Remove old & unused references to Stackprof. Prevent interaction with intentional usage of Stackprof
-
-# 1.6.0
-
-* Dynamic algorithm for selecting when to collect traces. Now, we will collect a
-  more complete cross-section of your application's performance, dynamically
-  tuned as your application runs.
-* Record and report 95th percentiles for each action
-* A variety of bug fixes
-
-# 1.5.5
-
-* Handle backslash escaped quotes inside mysql strings.
-
-# 1.5.4
-
-* Fix issue where error counts were being misreported
-* Politely ignore cases when `request.remote_ip` raises exceptions.
-
-# 1.5.3
-
-* Fix another minor bug related to iso8601 timestamps
+* Reporting object allocation metrics and mem delta with slow requests and jobs.
 
 # 1.5.2
 
-* Force timestamps to be iso8601 format
+* Fix deploy webhook endpoint
 
 # 1.5.1
 
-* Add `ignore_traces` config option to ignore SlowTransactions from certain URIs.
+* Collecting memory metrics on slow transactions
+* Collecting additional fields for slow transactions:
+  * hostname
+  * seconds_since_startup (larger memory increases and other other odd behavior more common when close to startup)
 
 # 1.5.0
 

data/ext/allocations/allocations.c

@@ -0,0 +1,84 @@
+#include <ruby/ruby.h>
+
+VALUE mScoutApm;
+VALUE mInstruments;
+VALUE cAllocations;
+
+#ifdef RUBY_INTERNAL_EVENT_NEWOBJ
+
+#include <sys/resource.h> // is this needed?
+#include <sys/time.h>
+#include <ruby/debug.h>
+
+static __thread uint64_t endpoint_allocations;
+void increment_allocations() {
+  endpoint_allocations++;
+}
+
+static VALUE
+get_allocation_count() {
+  return ULL2NUM(endpoint_allocations);
+}
+
+static void
+tracepoint_handler(VALUE tpval, void *data)
+{
+    rb_trace_arg_t *tparg = rb_tracearg_from_tracepoint(tpval);
+    if (rb_tracearg_event_flag(tparg) == RUBY_INTERNAL_EVENT_NEWOBJ) {
+        increment_allocations();
+    }
+}
+
+static VALUE
+set_gc_hook(rb_event_flag_t event)
+{
+    VALUE tpval;
+    // TODO - need to prevent applying the same tracepoint multiple times?
+    tpval = rb_tracepoint_new(0, event, tracepoint_handler, 0);
+    rb_tracepoint_enable(tpval);
+
+    return tpval;
+}
+
+void
+Init_hooks(VALUE module)
+{
+    set_gc_hook(RUBY_INTERNAL_EVENT_NEWOBJ);
+}
+
+void Init_allocations()
+{
+    mScoutApm = rb_define_module("ScoutApm");
+    mInstruments = rb_define_module_under(mScoutApm, "Instruments");
+    cAllocations = rb_define_class_under(mInstruments, "Allocations", rb_cObject);
+    rb_define_singleton_method(cAllocations, "count", get_allocation_count, 0);
+    rb_define_singleton_method(cAllocations, "count", get_allocation_count, 0);
+    rb_define_const(cAllocations, "ENABLED", Qtrue);
+    Init_hooks(mScoutApm);
+}
+
+#else
+
+static VALUE
+get_allocation_count() {
+  return ULL2NUM(0);
+}
+
+void
+Init_hooks(VALUE module)
+{
+}
+
+void Init_allocations()
+{
+    mScoutApm = rb_define_module("ScoutApm");
+    mInstruments = rb_define_module_under(mScoutApm, "Instruments");
+    cAllocations = rb_define_class_under(mInstruments, "Allocations", rb_cObject);
+    rb_define_singleton_method(cAllocations, "count", get_allocation_count, 0);
+    rb_define_singleton_method(cAllocations, "count", get_allocation_count, 0);
+    rb_define_const(cAllocations, "ENABLED", Qfalse);
+    Init_hooks(mScoutApm);
+}
+
+#endif //#ifdef RUBY_INTERNAL_EVENT_NEWOBJ
+

data/ext/allocations/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('allocations')

data/lib/scout_apm/agent/reporting.rb

@@ -24,35 +24,17 @@ module ScoutApm
         report_to_server
       end
 
+      MAX_AGE_TO_REPORT = (10 * 60) # ten minutes as seconds
+
       # In a running app, one process will get one period ready for delivery, the others will see 0.
       def report_to_server
-        period_to_report = ScoutApm::StoreReportingPeriodTimestamp.minutes_ago(2)
-
-        logger.debug("Attempting to claim #{period_to_report.to_s}")
-
-        did_write = layaway.with_claim(period_to_report) do |rps|
-          logger.debug("Succeeded claiming #{period_to_report.to_s}")
-
-          begin
-            merged = rps.inject { |memo, rp| memo.merge(rp) }
-            logger.debug("Merged #{rps.length} reporting periods, delivering")
-            deliver_period(merged)
-            true
-          rescue => e
-            logger.debug("Error merging reporting periods #{e.message}")
-            logger.debug("Error merging reporting periods #{e.backtrace}")
-            false
-          end
-
+        reporting_periods = layaway.periods_ready_for_delivery
+        reporting_periods.reject! {|rp| rp.timestamp.age_in_seconds > MAX_AGE_TO_REPORT }
+        reporting_periods.each do |rp|
+          deliver_period(rp)
         end
-
-        if !did_write
-          logger.debug("Failed to obtain claim for #{period_to_report.to_s}")
-        end
-
       end
 
-
       def deliver_period(reporting_period)
         metrics = reporting_period.metrics_payload
         slow_transactions = reporting_period.slow_transactions_payload
@@ -68,7 +50,7 @@ module ScoutApm
           :platform      => "ruby",
         }
 
-        log_deliver(metrics, slow_transactions, metadata, slow_jobs)
+        log_deliver(metrics, slow_transactions, metadata)
 
         payload = ScoutApm::Serializers::PayloadSerializer.serialize(metadata, metrics, slow_transactions, jobs, slow_jobs)
         logger.debug("Payload: #{payload}")
@@ -80,7 +62,7 @@ module ScoutApm
         logger.debug e.backtrace
       end
 
-      def log_deliver(metrics, slow_transactions, metadata, jobs_traces)
+      def log_deliver(metrics, slow_transactions, metadata)
         total_request_count = metrics.
           select { |meta,stats| meta.metric_name =~ /\AController/ }.
           inject(0) {|sum, (_, stat)| sum + stat.call_count }
@@ -93,12 +75,7 @@ module ScoutApm
                             "Recorded across (unknown) processes"
                           end
 
-        time_clause       = "[#{Time.parse(metadata[:agent_time]).strftime("%H:%M")}]"
-        metrics_clause    = "#{metrics.length} Metrics for #{total_request_count} requests"
-        slow_trans_clause = "#{slow_transactions.length} Slow Transaction Traces"
-        job_clause        = "#{jobs_traces.length} Job Traces"
-
-        logger.info "#{time_clause} Delivering #{metrics_clause} and #{slow_trans_clause} and #{job_clause}, #{process_log_str}."
+        logger.info "[#{Time.parse(metadata[:agent_time]).strftime("%H:%M")}] Delivering #{metrics.length} Metrics for #{total_request_count} requests and #{slow_transactions.length} Slow Transaction Traces, #{process_log_str}."
         logger.debug("Metrics: #{metrics.pretty_inspect}\nSlowTrans: #{slow_transactions.pretty_inspect}\nMetadata: #{metadata.inspect.pretty_inspect}")
       end
 

data/lib/scout_apm/agent.rb

@@ -19,13 +19,7 @@ module ScoutApm
     attr_accessor :metric_lookup # Hash used to lookup metric ids based on their name and scope
     attr_reader :slow_request_policy
     attr_reader :slow_job_policy
-
-    # Histogram of the cumulative requests since the start of the process
-    attr_reader :request_histograms
-
-    # Histogram of the requests, distinct by reporting period (minute)
-    # { StoreReportingPeriodTimestamp => RequestHistograms }
-    attr_reader :request_histograms_by_time
+    attr_reader :process_start_time # used when creating slow transactions to report how far from startup the transaction was recorded.
 
     # All access to the agent is thru this class method to ensure multiple Agent instances are not initialized per-Ruby process.
     def self.instance(options = {})
@@ -37,18 +31,24 @@ module ScoutApm
     # be started (when forking).
     def initialize(options = {})
       @started = false
+      @process_start_time = Time.now
       @options ||= options
-      @config = ScoutApm::Config.new(options[:config_path])
 
-      @slow_request_policy = ScoutApm::SlowRequestPolicy.new
+      # 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.
+      #
+      # Later in initialization, we reset @config to include the file.
+      @config = ScoutApm::Config.without_file
+
       @slow_job_policy = ScoutApm::SlowJobPolicy.new
-      @request_histograms = ScoutApm::RequestHistograms.new
-      @request_histograms_by_time = Hash.new { |h, k| h[k] = ScoutApm::RequestHistograms.new }
 
       @store          = ScoutApm::Store.new
       @layaway        = ScoutApm::Layaway.new
       @metric_lookup  = Hash.new
 
+      @slow_request_policy = ScoutApm::SlowRequestPolicy.new
+
       @capacity       = ScoutApm::Capacity.new
       @installed_instruments = []
     end
@@ -78,7 +78,11 @@ module ScoutApm
       end
 
       if app_server_missing?(options) && background_job_missing?
-        logger.warn "Couldn't find a supported app server or background job framework. #{force? ? 'Forcing agent to start' : 'Not starting agent'}."
+        if force?
+          logger.warn "Agent starting (forced)"
+        else
+          logger.warn "Deferring agent start. Standing by for first request"
+        end
         return false unless force?
       end
 
@@ -99,6 +103,7 @@ module ScoutApm
     # It initializes the agent and starts the worker thread (if appropiate).
     def start(options = {})
       @options.merge!(options)
+      @config = ScoutApm::Config.with_file(@config.value("config_file"))
       init_logger
       logger.info "Attempting to start Scout Agent [#{ScoutApm::VERSION}] on [#{environment.hostname}]"
 
@@ -112,10 +117,10 @@ module ScoutApm
 
       load_instruments if should_load_instruments?(options)
 
-      [ ScoutApm::Instruments::Process::ProcessCpu.new(environment.processors, logger),
-        ScoutApm::Instruments::Process::ProcessMemory.new(logger),
-        ScoutApm::Instruments::PercentileSampler.new(logger, 95),
-      ].each { |s| store.add_sampler(s) }
+      @samplers = [
+        ScoutApm::Instruments::Process::ProcessCpu.new(environment.processors, logger),
+        ScoutApm::Instruments::Process::ProcessMemory.new(logger)
+      ]
 
       app_server_load_hook
 
@@ -183,19 +188,14 @@ module ScoutApm
     def shutdown
       logger.info "Shutting down ScoutApm"
       return if !started?
-
       if @background_worker
-        logger.info("Stopping background worker")
         @background_worker.stop
         store.write_to_layaway(layaway, :force)
       end
 
       # Make sure we don't exit the process while the background worker is running its task.
       logger.debug "Joining background worker thread"
-      if @background_worker_thread
-        @background_worker_thread.wakeup
-        @background_worker_thread.join
-      end
+      @background_worker_thread.join if @background_worker_thread
     end
 
     def started?
@@ -232,19 +232,16 @@ module ScoutApm
       @background_worker = ScoutApm::BackgroundWorker.new
       @background_worker_thread = Thread.new do
         @background_worker.start {
+          # First, run periodic samplers. These should run once a minute,
+          # rather than per-request. "CPU Load" and similar.
+          run_samplers
+          capacity.process
+
           ScoutApm::Agent.instance.process_metrics
-          clean_old_percentiles
         }
       end
     end
 
-    def clean_old_percentiles
-      request_histograms_by_time.
-        keys.
-        select {|timestamp| timestamp.age_in_seconds > 60 * 10 }.
-        each {|old_timestamp| request_histograms_by_time.delete(old_timestamp) }
-    end
-
     # If we want to skip the app_server_check, then we must load it.
     def should_load_instruments?(options={})
       return true if options[:skip_app_server_check]
@@ -277,7 +274,10 @@ module ScoutApm
       install_instrument(ScoutApm::Instruments::Redis)
       install_instrument(ScoutApm::Instruments::InfluxDB)
       install_instrument(ScoutApm::Instruments::Elasticsearch)
-      install_instrument(ScoutApm::Instruments::Grape)
+
+      if StackProf.respond_to?(:fake?) && StackProf.fake?
+        logger.info 'StackProf not found - add `gem "stackprof"` to your Gemfile to enable advanced code profiling (only for Ruby 2.1+)'
+      end
     rescue
       logger.warn "Exception loading instruments:"
       logger.warn $!.message
@@ -304,6 +304,20 @@ module ScoutApm
       environment.deploy_integration
     end
 
+    # TODO: Extract a proper class / registery for these. They don't really belong here
+    def run_samplers
+      @samplers.each do |sampler|
+        begin
+          result = sampler.run
+          store.track_one!(sampler.metric_type, sampler.metric_name, result) if result
+        rescue => e
+          logger.info "Error reading #{sampler.human_name}"
+          logger.debug e.message
+          logger.debug e.backtrace.join("\n")
+        end
+      end
+    end
+
     def app_server_missing?(options = {})
       !environment.app_server_integration(true).found? && !options[:skip_app_server_check]
     end

data/lib/scout_apm/app_server_load.rb

@@ -34,8 +34,7 @@ module ScoutApm
         :app_server         => 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
+        :database_engine    => ScoutApm::Environment.instance.database_engine,
         :application_name   => ScoutApm::Environment.instance.application_name,
         :libraries          => ScoutApm::Utils::InstalledGems.new.run,
         :paas               => ScoutApm::Environment.instance.platform_integration.name

data/lib/scout_apm/attribute_arranger.rb

@@ -7,10 +7,6 @@ module ScoutApm
         case attribute
         when Array
           attribute_hash[attribute[0]] = subject.send(attribute[1])
-        when :bucket
-          attribute_hash[attribute] = subject.bucket_type
-        when :name
-          attribute_hash[attribute] = subject.bucket_name
         when Symbol
           attribute_hash[attribute] = subject.send(attribute)
         end

data/lib/scout_apm/background_worker.rb

@@ -12,7 +12,6 @@ module ScoutApm
     end
 
     def stop
-      ScoutApm::Agent.instance.logger.debug "Background Worker: stop requested"
       @keep_running = false
     end
 
@@ -26,33 +25,31 @@ module ScoutApm
       @task = block
 
       begin
-        ScoutApm::Agent.instance.logger.debug "Background Worker: Starting Background Worker, running every #{period} seconds"
+        ScoutApm::Agent.instance.logger.debug "Starting Background Worker, running every #{period} seconds"
 
         # The first run should be 1 period of time from now
         next_time = Time.now + period
 
         loop do
-          # Bail out if @keep_running is false
-          unless @keep_running
-            ScoutApm::Agent.instance.logger.debug "Background Worker: breaking from loop"
-            break
-          end
-
           now = Time.now
 
           # Sleep the correct amount of time to reach next_time
-          while now < next_time && @keep_running
+          while now < next_time
             sleep_time = next_time - now
             sleep(sleep_time) if sleep_time > 0
             now = Time.now
           end
 
+          # Bail out if @keep_running is false
+          break unless @keep_running
+
           @task.call
 
           # Adjust the next time to run forward by @periods until it is in the future
           while next_time <= now
             next_time += period
           end
+
         end
       rescue
         ScoutApm::Agent.instance.logger.debug "Background Worker Exception!"

data/lib/scout_apm/bucket_name_splitter.rb

@@ -1,15 +1,15 @@
 module ScoutApm
   module BucketNameSplitter
-    def bucket_type
+    def bucket
       split_metric_name(metric_name).first
     end
 
-    def bucket_name
+    def name
       split_metric_name(metric_name).last
     end
 
     def key
-      {:bucket => bucket_type, :name => bucket_name}
+      {:bucket => bucket, :name => name}
     end
 
     private

data/lib/scout_apm/call_set.rb

@@ -1,4 +1,5 @@
 module ScoutApm
+  # Encapsulates our logic to determine when a backtrace should be collected.
   class CallSet
 
     N_PLUS_ONE_MAGIC_NUMBER = 5 # Fetch backtraces on this number of calls to a layer. The caller data is only collected on this call to limit overhead.