scout_apm 3.0.0.pre13 → 3.0.0.pre14

data/lib/scout_apm/instruments/redis.rb

@@ -1,22 +1,26 @@
 module ScoutApm
   module Instruments
     class Redis
-      attr_reader :logger
+      attr_reader :context
 
-      def initalize(logger=ScoutApm::Agent.instance.logger)
-        @logger = logger
+      def initialize(context)
+        @context = context
         @installed = false
       end
 
+      def logger
+        context.logger
+      end
+
       def installed?
         @installed
       end
 
       def install
-        @installed = true
-
         if defined?(::Redis) && defined?(::Redis::Client)
-          ScoutApm::Agent.instance.logger.info "Instrumenting Redis"
+          @installed = true
+
+          logger.info "Instrumenting Redis"
 
           ::Redis::Client.class_eval do
             include ScoutApm::Tracer

data/lib/scout_apm/instruments/samplers.rb

@@ -0,0 +1,11 @@
+module ScoutApm
+  module Instruments
+    class Samplers
+      DEFAULT_SAMPLERS = [
+        ScoutApm::Instruments::Process::ProcessCpu,
+        ScoutApm::Instruments::Process::ProcessMemory,
+        ScoutApm::Instruments::PercentileSampler,
+      ]
+    end
+  end
+end

data/lib/scout_apm/instruments/sinatra.rb

@@ -1,9 +1,10 @@
+# XXX: Is this file used?
 module ScoutApm
   module Instruments
     class Sinatra
       attr_reader :logger
 
-      def initalize(logger=ScoutApm::Agent.instance.logger)
+      def initalize(logger=ScoutApm::Agent.instance.context.logger)
         @logger = logger
         @installed = false
       end
@@ -13,10 +14,10 @@ module ScoutApm
       end
 
       def install
-        @installed = true
-
         if defined?(::Sinatra) && defined?(::Sinatra::Base) && ::Sinatra::Base.private_method_defined?(:dispatch!)
-          ScoutApm::Agent.instance.logger.info "Instrumenting Sinatra"
+          @installed = true
+
+          logger.info "Instrumenting Sinatra"
           ::Sinatra::Base.class_eval do
             include ScoutApm::Tracer
             include ScoutApm::Instruments::SinatraInstruments

data/lib/scout_apm/layaway.rb

@@ -18,12 +18,13 @@ module ScoutApm
     # Must be sortable as an integer
     TIME_FORMAT = "%Y%m%d%H%M"
 
-    attr_accessor :config
-    attr_reader :environment
+    attr_reader :context
+    def initialize(context)
+      @context = context
+    end
 
-    def initialize(config, environment)
-      @config = config
-      @environment = environment
+    def logger
+      context.logger
     end
 
     # Returns a Pathname object with the fully qualified directory where the layaway files can be placed.
@@ -34,27 +35,27 @@ module ScoutApm
     def directory
       return @directory if @directory
 
-      data_file = config.value("data_file")
+      data_file = context.config.value("data_file")
       data_file = File.dirname(data_file) if data_file && !File.directory?(data_file)
 
       candidates = [
         data_file,
-        "#{environment.root}/tmp",
+        "#{context.environment.root}/tmp",
         "/tmp"
       ].compact
 
       found = candidates.detect { |dir| File.writable?(dir) }
-      ScoutApm::Agent.instance.logger.debug("Storing Layaway Files in #{found}")
+      logger.debug("Storing Layaway Files in #{found}")
       @directory = Pathname.new(found)
     end
 
     def write_reporting_period(reporting_period, files_limit = MAX_FILES_LIMIT)
       if at_layaway_file_limit?(files_limit)
-        ScoutApm::Agent.instance.logger.error("Hit layaway file limit. Not writing to layaway file")
+        logger.error("Hit layaway file limit. Not writing to layaway file")
         return false
       end
       filename = file_for(reporting_period.timestamp)
-      layaway_file = LayawayFile.new(filename)
+      layaway_file = LayawayFile.new(context, filename)
       layaway_file.write(reporting_period)
     end
 
@@ -74,28 +75,28 @@ module ScoutApm
       begin
         if f
           begin
-            ScoutApm::Agent.instance.logger.debug("Obtained Reporting Lock")
+            logger.debug("Obtained Reporting Lock")
 
             log_layaway_file_information
 
             files = all_files_for(timestamp).reject{|l| l.to_s == coordinator_file.to_s }
-            rps = files.map{ |layaway| LayawayFile.new(layaway).load }.compact
+            rps = files.map{ |layaway| LayawayFile.new(context, layaway).load }.compact
             if rps.any?
               yield rps
 
-              ScoutApm::Agent.instance.logger.debug("Deleting the now-reported layaway files for #{timestamp.to_s}")
+              logger.debug("Deleting the now-reported layaway files for #{timestamp.to_s}")
               delete_files_for(timestamp) # also removes the coodinator_file
 
-              ScoutApm::Agent.instance.logger.debug("Checking for any Stale layaway files")
+              logger.debug("Checking for any Stale layaway files")
               delete_stale_files(timestamp.to_time - STALE_AGE)
             else
               File.unlink(coordinator_file)
-              ScoutApm::Agent.instance.logger.debug("No layaway files to report")
+              logger.debug("No layaway files to report")
             end
 
             true
           rescue Exception => e
-            ScoutApm::Agent.instance.logger.debug("Caught an exception in with_claim, with the coordination file locked: #{e.message}, #{e.backtrace.inspect}")
+            logger.debug("Caught an exception in with_claim, with the coordination file locked: #{e.message}, #{e.backtrace.inspect}")
             raise
           ensure
             # Unlock the file when done!
@@ -111,7 +112,7 @@ module ScoutApm
 
     def delete_files_for(timestamp)
       all_files_for(timestamp).each { |layaway|
-        ScoutApm::Agent.instance.logger.debug("Deleting layaway file: #{layaway}")
+        logger.debug("Deleting layaway file: #{layaway}")
         File.unlink(layaway)
       }
     end
@@ -122,10 +123,10 @@ module ScoutApm
         compact.
         uniq.
         select { |timestamp| timestamp.to_i < older_than.strftime(TIME_FORMAT).to_i }.
-          tap  { |timestamps| ScoutApm::Agent.instance.logger.debug("Deleting stale layaway files with timestamps: #{timestamps.inspect}") }.
+          tap  { |timestamps| logger.debug("Deleting stale layaway files with timestamps: #{timestamps.inspect}") }.
         map    { |timestamp| delete_files_for(timestamp) }
     rescue => e
-      ScoutApm::Agent.instance.logger.debug("Problem deleting stale files: #{e.message}, #{e.backtrace.inspect}")
+      logger.debug("Problem deleting stale files: #{e.message}, #{e.backtrace.inspect}")
     end
 
     private
@@ -192,7 +193,7 @@ module ScoutApm
       ]
 
 
-      ScoutApm::Agent.instance.logger.debug("Total in #{directory}: #{files_in_temp}. Total Layaway Files: #{all_filenames.size}.  By Timestamp: #{count_per_timestamp.inspect}")
+      logger.debug("Total in #{directory}: #{files_in_temp}. Total Layaway Files: #{all_filenames.size}.  By Timestamp: #{count_per_timestamp.inspect}")
     end
   end
 end

data/lib/scout_apm/layaway_file.rb

@@ -2,18 +2,23 @@
 module ScoutApm
   class LayawayFile
     attr_reader :path
+    attr_reader :context
 
-    def initialize(path)
+    def initialize(context, path)
       @path = path
     end
 
+    def logger
+      context.logger
+    end
+
     def load
       data = File.open(path, "r") { |f| read_raw(f) }
       deserialize(data)
     rescue NameError, ArgumentError, TypeError => e
       # Marshal error
-      ScoutApm::Agent.instance.logger.info("Unable to load data from Layaway file, resetting.")
-      ScoutApm::Agent.instance.logger.debug("#{e.message}, #{e.backtrace.join("\n\t")}")
+      logger.info("Unable to load data from Layaway file, resetting.")
+      logger.debug("#{e.message}, #{e.backtrace.join("\n\t")}")
       nil
     end
 

data/lib/scout_apm/layer.rb

@@ -138,7 +138,7 @@ module ScoutApm
     # In Ruby 2.0+, we can pass the range directly to the caller to reduce the memory footprint.
     def caller_array
       # omits the first several callers which are in the ScoutAPM stack.
-      if ScoutApm::Environment.instance.ruby_2?
+      if ScoutApm::Agent.instance.context.environment.ruby_2?
         caller(3...BACKTRACE_CALLER_LIMIT)
       else
         caller[3...BACKTRACE_CALLER_LIMIT]
@@ -152,7 +152,7 @@ module ScoutApm
     end
 
     def start_sampling
-      if ScoutApm::Agent.instance.config.value('profile') && traced?
+      if ScoutApm::Agent.instance.context.config.value('profile') && traced?
         ScoutApm::Instruments::Stacks.update_indexes(frame_index, trace_index)
         ScoutApm::Instruments::Stacks.start_sampling
       else
@@ -161,7 +161,7 @@ module ScoutApm
     end
 
     def record_traces!
-      if ScoutApm::Agent.instance.config.value('profile')
+      if ScoutApm::Agent.instance.context.config.value('profile')
         ScoutApm::Instruments::Stacks.stop_sampling(false)
         if traced?
           traces.raw_traces = ScoutApm::Instruments::Stacks.profile_frames

data/lib/scout_apm/layer_converters/converter_base.rb

@@ -2,11 +2,13 @@ module ScoutApm
   module LayerConverters
     class ConverterBase
 
+      attr_reader :context
       attr_reader :request
       attr_reader :root_layer
       attr_reader :layer_finder
 
-      def initialize(request, layer_finder, store=nil)
+      def initialize(context, request, layer_finder, store=nil)
+        @context = context
         @request = request
         @layer_finder = layer_finder
         @store = store
@@ -218,17 +220,14 @@ module ScoutApm
 
       # Debug logging for scoutprof traces
       def debug_scoutprof(layer)
-        agent = ScoutApm::Agent.instance
-        config = agent.config
-
         if layer.type =~ %r{^(Controller|Queue|Job)$}.freeze
-          if config.value('profile')
-            agent.logger.debug do
+          if context.config.value('profile')
+            context.logger.debug do
               traces_inspect = layer.traces.inspect
               "****** Slow Request #{layer.type} Traces (#{layer.name}, tet: #{layer.total_exclusive_time}, tct: #{layer.total_call_time}), total raw traces: #{layer.traces.cube.total_count}, total clean traces: #{layer.traces.total_count}, skipped gc: #{layer.traces.skipped_in_gc}, skipped handler: #{layer.traces.skipped_in_handler}, skipped registered #{layer.traces.skipped_in_job_registered}, skipped not_running #{layer.traces.skipped_in_not_running}:\n#{traces_inspect}"
             end
           else
-            agent.logger.debug "****** Slow Request #{layer.type} Traces: Scoutprof is not enabled"
+            context.logger.debug "****** Slow Request #{layer.type} Traces: Scoutprof is not enabled"
           end
         end
       end

data/lib/scout_apm/layer_converters/database_converter.rb

@@ -3,7 +3,7 @@ module ScoutApm
     class DatabaseConverter < ConverterBase
       def initialize(*)
         super
-        @db_query_metric_set = DbQueryMetricSet.new
+        @db_query_metric_set = DbQueryMetricSet.new(context)
       end
 
       def register_hooks(walker)

data/lib/scout_apm/layer_converters/histograms.rb

@@ -4,8 +4,8 @@ module ScoutApm
       # Updates immediate and long-term histograms for both job and web requests
       def record!
         if request.unique_name != :unknown
-          ScoutApm::Agent.instance.request_histograms.add(request.unique_name, root_layer.total_call_time)
-          ScoutApm::Agent.instance.request_histograms_by_time[@store.current_timestamp].
+          context.request_histograms.add(request.unique_name, root_layer.total_call_time)
+          context.request_histograms_by_time[@store.current_timestamp].
             add(request.unique_name, root_layer.total_call_time)
         end
       end

data/lib/scout_apm/layer_converters/slow_job_converter.rb

@@ -10,7 +10,7 @@ module ScoutApm
       ###################
       def record!
         return nil unless request.job?
-        @points = ScoutApm::Agent.instance.slow_job_policy.score(request)
+        @points = context.slow_job_policy.score(request)
 
         # Let the store know we're here, and if it wants our data, it will call
         # back into #call
@@ -29,10 +29,10 @@ module ScoutApm
         return nil unless layer_finder.queue
         return nil unless layer_finder.job
 
-        ScoutApm::Agent.instance.slow_job_policy.stored!(request)
+        context.slow_job_policy.stored!(request)
 
         # record the change in memory usage
-        mem_delta = ScoutApm::Instruments::Process::ProcessMemory.rss_to_mb(request.capture_mem_delta!)
+        mem_delta = ScoutApm::Instruments::Process::ProcessMemory.new(context).rss_to_mb(request.capture_mem_delta!)
 
         timing_metrics, allocation_metrics = create_metrics
 
@@ -41,6 +41,7 @@ module ScoutApm
         end
 
         SlowJobRecord.new(
+          context,
           queue_layer.name,
           job_layer.name,
           root_layer.stop_time,

data/lib/scout_apm/layer_converters/slow_request_converter.rb

@@ -6,7 +6,7 @@ module ScoutApm
       ###################
       def record!
         return nil unless request.web?
-        @points = ScoutApm::Agent.instance.slow_request_policy.score(request)
+        @points = context.slow_request_policy.score(request)
 
         # Let the store know we're here, and if it wants our data, it will call
         # back into #call
@@ -25,10 +25,10 @@ module ScoutApm
         return nil unless request.web?
         return nil unless scope_layer
 
-        ScoutApm::Agent.instance.slow_request_policy.stored!(request)
+        context.slow_request_policy.stored!(request)
 
         # record the change in memory usage
-        mem_delta = ScoutApm::Instruments::Process::ProcessMemory.rss_to_mb(@request.capture_mem_delta!)
+        mem_delta = ScoutApm::Instruments::Process::ProcessMemory.new(context).rss_to_mb(@request.capture_mem_delta!)
 
         uri = request.annotations[:uri] || ""
 
@@ -38,7 +38,8 @@ module ScoutApm
           allocation_metrics = {}
         end
 
-        SlowTransaction.new(uri,
+        SlowTransaction.new(context,
+                            uri,
                             scope_layer.legacy_metric_name,
                             root_layer.total_call_time,
                             timing_metrics,

data/lib/scout_apm/logger.rb

@@ -0,0 +1,143 @@
+# Pass in the "root" of the application you're using.
+#   - Rails.root
+#   - `Dir.pwd`
+#
+# Currently Valid opts:
+# :force => Boolean                        - used to reinitialize logger.
+# :log_file_path => String                 - explicitly set what file to send the log to
+# :stdout => true                          - explicitly force the log to write to stdout (if set, ignore log_file_path)
+# :stderr => true                          - explicitly force the log to write to stderr (if set, ignore log_file_path)
+# :logger_class => Class or String         - a class to use as the underlying logger. Defaults to Ruby's Logger. See notes
+# :log_level => symbol, string, or integer - defualts to INFO level
+#
+# The :logger_class option
+#   - allows any class to be used as the underlying logger. Currently requires to respond to:
+#     - debug, info, warn, error, fatal in both string and block form.
+#     - #level= with a number (0 = debug, 1 = info, 2= warn, 3=error, 4=fatal)
+#     - #formatter= that takes a Ruby Logger::Formatter class. This method must be here, but the value may be ignored
+#
+#config.value('log_level').downcase
+#
+module ScoutApm
+  class Logger
+    attr_reader :log_destination
+
+    def initialize(environment_root, opts={})
+      @opts = opts
+      @environment_root = environment_root
+
+      @log_destination = determine_log_destination
+      @logger = build_logger
+      self.log_level = log_level_from_opts
+      @logger.formatter = build_formatter
+    end
+
+    # Delegate calls to the underlying logger
+    def debug(*args, &block); @logger.debug(*args, &block); end
+    def info(*args, &block); @logger.info(*args, &block); end
+    def warn(*args, &block); @logger.warn(*args, &block); end
+    def error(*args, &block); @logger.error(*args, &block); end
+    def fatal(*args, &block); @logger.fatal(*args, &block); end
+
+    def log_level=(level)
+      @logger.level = level
+    end
+
+    def log_file_path
+      @opts.fetch(:log_file_path, "#{@environment_root}/log") || "#{@environment_root}/log"
+    end
+
+    def stdout?
+      @opts[:stdout] || @opts[:log_file_path] == "STDOUT"
+    end
+
+    def stderr?
+      @opts[:stderr] || @opts[:log_file_path] == "STDERR"
+    end
+
+    private
+
+    def build_logger
+      logger_class.new(@log_destination)
+    end
+
+    def logger_class
+      klass = @opts.fetch(:logger_class, ::Logger)
+      case klass
+      when String
+        result = KlassHelper.lookup(klass)
+        if result == :missing_class
+          ::Logger
+        else
+          result
+        end
+      when Class
+        klass
+      else
+        ::Logger
+      end
+    end
+
+    def build_formatter
+      if stdout? || stderr?
+        TaggedFormatter.new
+      else
+        DefaultFormatter.new
+      end
+    end
+
+    def log_level_from_opts
+      case @opts[:log_level]
+      when "debug" then ::Logger::DEBUG
+      when "info" then ::Logger::INFO
+      when "warn" then ::Logger::WARN
+      when "error" then ::Logger::ERROR
+      when "fatal" then ::Logger::FATAL
+      else ::Logger::INFO
+      end
+    end
+
+    def determine_log_destination
+      case true
+      when stdout?
+        STDOUT
+      when stderr?
+        STDERR
+      when validate_path(@opts[:log_file])
+        @opts[:log_file]
+      when validate_path("#{log_file_path}/scout_apm.log")
+        "#{log_file_path}/scout_apm.log"
+      else
+        # Safe fallback
+        STDOUT
+      end
+    end
+
+    # Check if this path is ok for a log file.
+    # Does it exist?
+    # Is it writable?
+    # XXX: Implement
+    def validate_path(candidate)
+      !candidate.nil?
+    end
+
+
+    class DefaultFormatter < ::Logger::Formatter
+      def call(severity, time, progname, msg)
+        # since STDOUT isn't exclusive like the scout_apm.log file, apply a prefix.
+        # XXX: Pass in context to the formatter
+        "[#{Utils::Time.to_s(time)} #{ScoutApm::Agent.instance.context.environment.hostname} (#{$$})] #{severity} : #{msg}\n"
+      end
+    end
+
+    # since STDOUT & STDERR isn't only used for ScoutApm logging, apply a
+    # prefix to make it easily greppable
+    class TaggedFormatter < DefaultFormatter
+      TAG = "[Scout] "
+
+      def call(severity, time, progname, msg)
+        TAG + super
+      end
+    end
+  end
+end