scout_apm 0.1.6 → 0.1.7

data/lib/scout_apm/app_server_load.rb

@@ -0,0 +1,29 @@
+module ScoutApm
+  class AppServerLoad
+    attr_reader :logger
+
+    def initialize(logger: Agent.instance.logger)
+      @logger = logger
+    end
+
+    def run
+      logger.info("Sending Startup Info: #{data.inspect}")
+      payload = ScoutApm::Serializers::AppServerLoadSerializer.serialize(data)
+      reporter = Reporter.new(type: :app_server_load)
+      reporter.report(payload)
+    rescue => e
+      logger.debug("Failed Startup Info - #{e.message} \n\t#{e.backtrace.join("\t\n")}")
+    end
+
+    def data
+      { server_time:       Time.now,
+        framework:         ScoutApm::Environment.instance.framework_integration.name,
+        framework_version: ScoutApm::Environment.instance.framework_integration.version,
+        ruby_version:      RUBY_VERSION,
+        hostname:          ScoutApm::Environment.instance.hostname,
+        database_engine:   ScoutApm::Environment.instance.database_engine,
+        application_name:  ScoutApm::Environment.instance.application_name,
+      }
+    end
+  end
+end

data/lib/scout_apm/background_worker.rb

@@ -1,21 +1,21 @@
-# Used to run a given task every 60 seconds. 
+# Used to run a given task every 60 seconds.
 class ScoutApm::BackgroundWorker
   # in seconds, time between when the worker thread wakes up and runs.
   PERIOD = 60
-  
+
   def initialize
     @keep_running = true
   end
-  
+
   def stop
     @keep_running = false
   end
-  
+
   # Runs the task passed to +start+ once.
   def run_once
     @task.call if @task
   end
-  
+
   # Starts running the passed block every 60 seconds (starting now).
   def start(&block)
     @task = block
@@ -40,4 +40,4 @@ class ScoutApm::BackgroundWorker
       ScoutApm::Agent.instance.logger.debug $!.backtrace
     end
   end
-end
+end

data/lib/scout_apm/capacity.rb

@@ -1,54 +1,54 @@
 # Encapsulates logic for determining capacity utilization of the Ruby processes.
 class ScoutApm::Capacity
-	attr_reader :processing_start_time, :accumulated_time, :transaction_entry_time
+  attr_reader :processing_start_time, :accumulated_time, :transaction_entry_time
 
-	def initialize
-		@processing_start_time = Time.now
-		@lock ||= Mutex.new # the transaction_entry_time could be modified while processing a request or when #process is called.
-		@accumulated_time = 0.0
-	end
-	
-	# Called when a transaction is traced.
-	def start_transaction!
-		@lock.synchronize do
-			@transaction_entry_time = Time.now
-		end
-	end
+  def initialize
+    @processing_start_time = Time.now
+    @lock ||= Mutex.new # the transaction_entry_time could be modified while processing a request or when #process is called.
+    @accumulated_time = 0.0
+  end
 
-	# Called when a transaction completes to record its time used.
-	def finish_transaction!
-		@lock.synchronize do
-			if transaction_entry_time
-				@accumulated_time += (Time.now - transaction_entry_time).to_f
-			else
-				ScoutApm::Agent.instance.logger.warn "No transaction entry time. Not recording capacity metrics for transaction."
-			end
-			@transaction_entry_time = nil
-		end
-	end
+  # Called when a transaction is traced.
+  def start_transaction!
+    @lock.synchronize do
+      @transaction_entry_time = Time.now
+    end
+  end
 
-	# Ran when sending metrics to server. Reports capacity usage metrics.
-	def process
-		process_time = Time.now
-		ScoutApm::Agent.instance.logger.debug "Processing capacity usage for [#{@processing_start_time}] to [#{process_time}]. Time Spent: #{@accumulated_time}."
-		@lock.synchronize do
-			time_spent = @accumulated_time
-			@accumulated_time = 0.0
-			# If a transaction is still running, capture its running time up to now and 
-			# reset the +transaction_entry_time+ to now. 
-			if @transaction_entry_time
-				time_spent += (process_time - @transaction_entry_time).to_f
-				ScoutApm::Agent.instance.logger.debug "A transaction is running while calculating capacity. Start time: [#{transaction_entry_time}]. Will update the entry time to [#{process_time}]."
-				@transaction_entry_time = process_time # prevent from over-counting capacity usage. update the transaction start time to now.
-			end
-			time_spent = 0.0 if time_spent < 0.0
+  # Called when a transaction completes to record its time used.
+  def finish_transaction!
+    @lock.synchronize do
+      if transaction_entry_time
+        @accumulated_time += (Time.now - transaction_entry_time).to_f
+      else
+        ScoutApm::Agent.instance.logger.warn "No transaction entry time. Not recording capacity metrics for transaction."
+      end
+      @transaction_entry_time = nil
+    end
+  end
 
-			window = (process_time - processing_start_time).to_f # time period we are evaulating capacity usage.
-			window = 1.0 if window <= 0.0 # prevent divide-by-zero if clock adjusted.
-			capacity = time_spent / window
-			ScoutApm::Agent.instance.logger.debug "Instance/Capacity: #{capacity}"
-			ScoutApm::Agent.instance.store.track!("Instance/Capacity",capacity,:scope => nil)
-			@processing_start_time = process_time
-		end
-	end
-end
+  # Ran when sending metrics to server. Reports capacity usage metrics.
+  def process
+    process_time = Time.now
+    ScoutApm::Agent.instance.logger.debug "Processing capacity usage for [#{@processing_start_time}] to [#{process_time}]. Time Spent: #{@accumulated_time}."
+    @lock.synchronize do
+      time_spent = @accumulated_time
+      @accumulated_time = 0.0
+      # If a transaction is still running, capture its running time up to now and
+      # reset the +transaction_entry_time+ to now.
+      if @transaction_entry_time
+        time_spent += (process_time - @transaction_entry_time).to_f
+        ScoutApm::Agent.instance.logger.debug "A transaction is running while calculating capacity. Start time: [#{transaction_entry_time}]. Will update the entry time to [#{process_time}]."
+        @transaction_entry_time = process_time # prevent from over-counting capacity usage. update the transaction start time to now.
+      end
+      time_spent = 0.0 if time_spent < 0.0
+
+      window = (process_time - processing_start_time).to_f # time period we are evaulating capacity usage.
+      window = 1.0 if window <= 0.0 # prevent divide-by-zero if clock adjusted.
+      capacity = time_spent / window
+      ScoutApm::Agent.instance.logger.debug "Instance/Capacity: #{capacity}"
+      ScoutApm::Agent.instance.store.track!("Instance/Capacity",capacity,:scope => nil)
+      @processing_start_time = process_time
+    end
+  end
+end

data/lib/scout_apm/config.rb

@@ -6,8 +6,8 @@ require 'scout_apm/environment'
 module ScoutApm
   class Config
     DEFAULTS =  {
-        'host' => 'https://apm.scoutapp.com',
-        'log_level' => 'info'
+        'host'      => 'https://apm.scoutapp.com',
+        'log_level' => 'info',
     }.freeze
 
     def initialize(config_path = nil)
@@ -25,7 +25,7 @@ module ScoutApm
     private
 
     def config_path
-      @config_path || File.join(ScoutApm::Environment.new.root, "config", "scout_apm.yml")
+      @config_path || File.join(ScoutApm::Environment.instance.root, "config", "scout_apm.yml")
     end
 
     def config_file
@@ -37,14 +37,14 @@ module ScoutApm
     end
 
     def config_environment
-      @config_environment ||= ScoutApm::Environment.new.env
+      @config_environment ||= ScoutApm::Environment.instance.env
     end
 
     def load_file
       settings_hash = {}
       begin
         if File.exist?(config_file)
-          settings_hash = YAML.load(ERB.new(File.read(config_file)).result(binding))[config_environment] || {} 
+          settings_hash = YAML.load(ERB.new(File.read(config_file)).result(binding))[config_environment] || {}
         else
           logger.warn "No config file found at [#{config_file}]."
         end

data/lib/scout_apm/context.rb

@@ -10,7 +10,7 @@ class ScoutApm::Context
     @user = {}
   end
 
-  # Generates a hash representation of the Context. 
+  # Generates a hash representation of the Context.
   # Example: {:monthly_spend => 100, :user => {:ip => '127.0.0.1'}}
   def to_hash
     @extra.merge({:user => @user})
@@ -77,7 +77,7 @@ class ScoutApm::Context
 
   # take the entire Hash vs. just the value so the logger output is more helpful on error.
   def value_valid?(key_value)
-    # ensure one of our accepted types. 
+    # ensure one of our accepted types.
     value = key_value.values.last
     if !valid_type?([String, Symbol, Numeric, Time, Date, TrueClass, FalseClass],value)
       ScoutApm::Agent.instance.logger.warn "The value for [#{key_value.keys.first}] is not a valid type [#{value.class}]."
@@ -102,4 +102,4 @@ class ScoutApm::Context
     end
     true
   end
-end
+end

data/lib/scout_apm/environment.rb

@@ -1,68 +1,77 @@
+require 'singleton'
+
 # Used to retrieve environment information for this application.
 module ScoutApm
   class Environment
+    include Singleton
+
+    # I've put Thin and Webrick last as they are often used in development and included in Gemfiles
+    # but less likely used in production.
+    SERVER_INTEGRATIONS = [
+      ScoutApm::ServerIntegrations::Passenger.new(Logger.new(STDOUT)),
+      ScoutApm::ServerIntegrations::Unicorn.new(Logger.new(STDOUT)),
+      ScoutApm::ServerIntegrations::Rainbows.new(Logger.new(STDOUT)),
+      ScoutApm::ServerIntegrations::Puma.new(Logger.new(STDOUT)),
+      ScoutApm::ServerIntegrations::Thin.new(Logger.new(STDOUT)),
+      ScoutApm::ServerIntegrations::Webrick.new(Logger.new(STDOUT)),
+      ScoutApm::ServerIntegrations::Null.new(Logger.new(STDOUT)), # must be last
+    ]
+
+    FRAMEWORK_INTEGRATIONS = [
+      ScoutApm::FrameworkIntegrations::Rails2.new,
+      ScoutApm::FrameworkIntegrations::Rails3Or4.new,
+      ScoutApm::FrameworkIntegrations::Sinatra.new,
+      ScoutApm::FrameworkIntegrations::Ruby.new, # Fallback if none match
+    ]
+
     def env
-      @env ||= case framework
-               when :rails
-                 RAILS_ENV.dup
-               when :rails3_or_4
-                 Rails.env
-               when :sinatra
-                 ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
-               when :ruby
-                 ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
-               end
+      @env ||= framework_integration.env
     end
 
     def framework
-      @framework ||= case
-                      when defined?(::Rails) && defined?(ActionController)
-                        if Rails::VERSION::MAJOR < 3
-                          :rails
-                        else
-                          :rails3_or_4
-                        end
-                      when defined?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra
-                      else :ruby
-                      end
+      framework_integration.name
+    end
+
+    def framework_integration
+      @framework ||= FRAMEWORK_INTEGRATIONS.detect{ |integration| integration.present? }
+    end
+
+    def application_name
+      Agent.instance.config.value("name") || framework_integration.application_name
     end
 
     def database_engine
       default = :mysql
 
       if defined?(ActiveRecord::Base)
-        return default unless ActiveRecord::Base.connected?
-
-        case ActiveRecord::Base.connection.class.to_s
-        when "ActiveRecord::ConnectionAdapters::MysqlAdapter"
-          :mysql
-        when "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
-          :postgres
-        when "ActiveRecord::ConnectionAdapters::SQLite3Adapter"
-          :sqlite
+        config = ActiveRecord::Base.connection_config
+        if config && config[:adapter]
+          case config[:adapter]
+          when "postgres" then :postgres
+          when "sqlite3"  then :sqlite
+          when "mysql"    then :mysql
+          else default
+          end
         else
           default
         end
       else
-        # TODO: detection outside of Rails
+        # TODO: Figure out how to detect outside of Rails context. (sequel, ROM, etc)
         default
       end
     end
 
     def processors
-      return @processors if @processors
-      unless @processors
-        proc_file = '/proc/cpuinfo'
-        if !File.exist?(proc_file)
-          @processors = 1
-        elsif `cat #{proc_file} | grep 'model name' | wc -l` =~ /(\d+)/
-          @processors = $1.to_i
-        end
-        if @processors < 1
-          @processors = 1
-        end 
-      end
-      @processors
+      @processors ||= begin
+                        proc_file = '/proc/cpuinfo'
+                        processors = if !File.exist?(proc_file)
+                                       1
+                                     else
+                                       lines = File.read("/proc/cpuinfo").lines.to_a
+                                       lines.grep(/^processor\s*:/i).size
+                                     end
+                        [processors, 1].compact.max
+                      end
     end
 
     def root
@@ -82,73 +91,28 @@ module ScoutApm
     end
 
     def hostname
-      heroku? ? ENV['DYNO'] : Socket.gethostname
+      @hostname ||= heroku? ? ENV['DYNO'] : Socket.gethostname
     end
 
+
+    # Returns the whole integration object
     # This needs to be improved. Frequently, multiple app servers gem are present and which
     # ever is checked first becomes the designated app server.
     #
-    # I've put Thin and Webrick last as they are often used in development and included in Gemfiles 
-    # but less likely used in production. 
-    #
-    # Next step: (1) list out all detected app servers (2) install hooks for those that need it (passenger, rainbows, unicorn). 
-    #
-    # Believe the biggest downside is the master process for forking app servers will get a background worker. Not sure how this will
-    # impact metrics (it shouldn't process requests).
-    def app_server
-      @app_server ||= if passenger? then :passenger
-                    elsif rainbows? then :rainbows
-                    elsif unicorn? then :unicorn
-                    elsif puma? then :puma
-                    elsif thin? then :thin
-                    elsif webrick? then :webrick
-                    else nil
-                    end
-    end
-
-    ### app server related-checks
-    def thin?
-      if defined?(::Thin) && defined?(::Thin::Server)
-        # Ensure Thin is actually initialized. It could just be required and not running.
-        ObjectSpace.each_object(Thin::Server) { |x| return true }
-        false
-      end
-    end
-
-    # Called via +#forking?+ since Passenger forks. Adds an event listener to start the worker thread
-    # inside the passenger worker process.
-    # Background: http://www.modrails.com/documentation/Users%20guide%20Nginx.html#spawning%5Fmethods%5Fexplained
-    def passenger?
-      (defined?(::Passenger) && defined?(::Passenger::AbstractServer)) || defined?(::PhusionPassenger)
+    # Next step: (1) list out all detected app servers (2) install hooks for those that need it (passenger, rainbows, unicorn).
+    def app_server_integration
+      @app_server = SERVER_INTEGRATIONS.detect{ |integration| integration.present? }
     end
 
-    def webrick?
-      defined?(::WEBrick) && defined?(::WEBrick::VERSION)
-    end
-
-    def rainbows?
-      if defined?(::Rainbows) && defined?(::Rainbows::HttpServer)
-        ObjectSpace.each_object(::Rainbows::HttpServer) { |x| return true }
-        false
-      end
-    end
-
-    def unicorn?
-      if defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
-        # Ensure Unicorn is actually initialized. It could just be required and not running.
-        ObjectSpace.each_object(::Unicorn::HttpServer) { |x| return true }
-        false
-      end
-    end
-
-    def puma?
-      defined?(::Puma) && File.basename($0) == 'puma'
+    # App server's name (symbol)
+    def app_server
+      app_server_integration.name
     end
 
-    # If forking, don't start worker thread in the master process. Since it's started as a Thread, it won't survive
-    # the fork.
+    # If forking, don't start worker thread in the master process. Since it's
+    # started as a Thread, it won't survive the fork.
     def forking?
-      passenger? or unicorn? or rainbows? or puma?
+      app_server_integration.forking?
     end
 
     ### ruby checks

data/lib/scout_apm/framework_integrations/rails_2.rb

@@ -0,0 +1,32 @@
+module ScoutApm
+  module FrameworkIntegrations
+    class Rails2
+      def name
+        :rails
+      end
+
+      def version
+        Rails::VERSION::STRING
+      end
+
+      def present?
+        defined?(::Rails) &&
+          defined?(ActionController) &&
+          Rails::VERSION::MAJOR < 3
+      end
+
+      def application_name
+        if defined?(::Rails)
+          ::Rails.application.class.to_s
+            .sub(/::Application$/, '')
+        end
+      rescue
+        nil
+      end
+
+      def env
+        RAILS_ENV.dup
+      end
+    end
+  end
+end