scout_apm 0.1.6 → 0.1.7

data/lib/scout_apm/framework_integrations/rails_3_or_4.rb

@@ -0,0 +1,33 @@
+module ScoutApm
+  module FrameworkIntegrations
+    class Rails3Or4
+      def name
+        :rails3_or_4
+      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
+      end
+
+    end
+  end
+end

data/lib/scout_apm/framework_integrations/ruby.rb

@@ -0,0 +1,26 @@
+module ScoutApm
+  module FrameworkIntegrations
+    class Ruby
+      def name
+        :ruby
+      end
+
+      def version
+        "Unknown"
+      end
+
+      def present?
+        true
+      end
+
+      # TODO: Fetch the name (Somehow?)
+      def application_name
+        "Ruby"
+      end
+
+      def env
+        ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+      end
+    end
+  end
+end

data/lib/scout_apm/framework_integrations/sinatra.rb

@@ -0,0 +1,27 @@
+module ScoutApm
+  module FrameworkIntegrations
+    class Sinatra
+      def name
+        :sinatra
+      end
+
+      def version
+        Sinatra::VERSION
+      end
+
+      def present?
+        defined?(::Sinatra) &&
+          defined?(::Sinatra::Base)
+      end
+
+      # TODO: Fetch the name
+      def application_name
+        "Sinatra"
+      end
+
+      def env
+        ENV['RACK_ENV'] || ENV['RAILS_ENV'] || 'development'
+      end
+    end
+  end
+end

data/lib/scout_apm/instruments/active_record_instruments.rb

@@ -3,7 +3,7 @@ require 'scout_apm/utils/sql_sanitizer'
 module ScoutApm
   module Instruments
     # Contains ActiveRecord instrument, aliasing +ActiveRecord::ConnectionAdapters::AbstractAdapter#log+ calls
-    # to trace calls to the database. 
+    # to trace calls to the database.
     module ActiveRecordInstruments
       def self.included(instrumented_class)
         ScoutApm::Agent.instance.logger.debug "Instrumenting #{instrumented_class.inspect}"

data/lib/scout_apm/instruments/mongoid_instruments.rb

@@ -7,4 +7,4 @@ if defined?(::Mongoid) and !defined?(::Moped)
       instrument_method method, :metric_name => "MongoDB/\#{@klass}/#{method}"
     end
   end
-end
+end

data/lib/scout_apm/instruments/moped_instruments.rb

@@ -12,13 +12,13 @@ if defined?(::Moped)
     end
     alias_method :process_without_scout_instruments, :process
     alias_method :process, :process_with_scout_instruments
-    
+
     # replaces values w/ ?
     def scout_sanitize_log(log)
       return nil if log.length > 1000 # safeguard - don't sanitize large SQL statements
-      log.gsub(/(=>")((?:[^"]|"")*)"/) do 
+      log.gsub(/(=>")((?:[^"]|"")*)"/) do
         $1 + '?' + '"'
       end
     end
   end
-end
+end

data/lib/scout_apm/instruments/net_http.rb

@@ -2,7 +2,7 @@ if defined?(::Net) && defined?(Net::HTTP)
   ScoutApm::Agent.instance.logger.debug "Instrumenting Net::HTTP"
   Net::HTTP.class_eval do
     include ScoutApm::Tracer
-    
+
     def request_with_scout_instruments(*args,&block)
       self.class.instrument("HTTP/request", :desc => "#{(@address+args.first.path.split('?').first)[0..99]}") do
         request_without_scout_instruments(*args,&block)
@@ -11,4 +11,4 @@ if defined?(::Net) && defined?(Net::HTTP)
     alias request_without_scout_instruments request
     alias request request_with_scout_instruments
   end
-end
+end

data/lib/scout_apm/instruments/process/process_cpu.rb

@@ -1,26 +1,47 @@
-module ScoutApm::Instruments
-  module Process
-    class ProcessCpu
-      def initialize(num_processors)
-        @num_processors = num_processors || 1
-      end
+module ScoutApm
+  module Instruments
+    module Process
+      class ProcessCpu
+        attr_reader :logger
+
+        def initialize(num_processors, logger)
+          @num_processors = num_processors || 1
+          @logger = logger
+
+          t = ::Process.times
+          @last_run = Time.now
+          @last_utime = t.utime
+          @last_stime = t.stime
+        end
+
+        def metric_name
+          "CPU/Utilization"
+        end
+
+        def human_name
+          "Process CPU"
+        end
 
-      def run
-        res=nil
-        now = Time.now
-        t = ::Process.times
-        if @last_run
-          elapsed_time = now - @last_run
-          if elapsed_time >= 1
-            user_time_since_last_sample = t.utime - @last_utime
-            system_time_since_last_sample = t.stime - @last_stime
-            res = ((user_time_since_last_sample + system_time_since_last_sample)/(elapsed_time * @num_processors))*100
+        def run
+          res = nil
+          now = Time.now
+          t = ::Process.times
+          if @last_run
+            elapsed_time = now - @last_run
+            if elapsed_time >= 1
+              user_time_since_last_sample = t.utime - @last_utime
+              system_time_since_last_sample = t.stime - @last_stime
+              res = ((user_time_since_last_sample + system_time_since_last_sample)/(elapsed_time * @num_processors))*100
+            end
           end
+          @last_utime = t.utime
+          @last_stime = t.stime
+          @last_run = now
+
+          logger.debug "#{human_name}: #{res.inspect} [#{Environment.instance.processors} CPU(s)]"
+
+          return res
         end
-        @last_utime = t.utime
-        @last_stime = t.stime
-        @last_run = now
-        return res
       end
     end
   end

data/lib/scout_apm/instruments/process/process_memory.rb

@@ -1,39 +1,54 @@
-module ScoutApm::Instruments
-  module Process
-    class ProcessMemory
-      def run
-        res=nil
-        platform = RUBY_PLATFORM.downcase
-
-        if platform =~ /linux/
-          res = get_mem_from_procfile
-        elsif platform =~ /darwin9/ # 10.5
-          res = get_mem_from_shell("ps -o rsz")
-        elsif platform =~ /darwin1[01]/ # 10.6 & 10.7
-          res = get_mem_from_shell("ps -o rss")
+module ScoutApm
+  module Instruments
+    module Process
+      class ProcessMemory
+        attr_reader :logger
+
+        def initialize(logger)
+          @logger = logger
         end
-        return res
-      end
 
-      private
+        def metric_name
+          "Memory/Physical"
+        end
 
-      def get_mem_from_procfile
-        res = nil
-        proc_status = File.open(procfile, "r") { |f| f.read_nonblock(4096).strip }
-        if proc_status =~ /RSS:\s*(\d+) kB/i
-          res= $1.to_f / 1024.0
+        def human_name
+          "Process Memory"
         end
-        res
-      end
 
-      def procfile
-        "/proc/#{$$}/status"
-      end
+        def run
+          case RUBY_PLATFORM.downcase
+          when /linux/
+            get_mem_from_procfile
+          when /darwin9/ # 10.5
+            get_mem_from_shell("ps -o rsz")
+          when /darwin1[0123]/ # 10.6 - 10.10
+            get_mem_from_shell("ps -o rss")
+          else
+            0 # What default? was nil.
+          end.tap { |res| logger.debug "#{human_name}: #{res.inspect}" }
+        end
 
-      # memory in MB the current process is using
-      def get_mem_from_shell(command)
-        res = `#{command} #{$$}`.split("\n")[1].to_f / 1024.0 #rescue nil
-        res
+        private
+
+        def get_mem_from_procfile
+          res = nil
+          proc_status = File.open(procfile, "r") { |f| f.read_nonblock(4096).strip }
+          if proc_status =~ /RSS:\s*(\d+) kB/i
+            res= $1.to_f / 1024.0
+          end
+          res
+        end
+
+        def procfile
+          "/proc/#{$$}/status"
+        end
+
+        # memory in MB the current process is using
+        def get_mem_from_shell(command)
+          res = `#{command} #{$$}`.split("\n")[1].to_f / 1024.0 #rescue nil
+          res
+        end
       end
     end
   end

data/lib/scout_apm/instruments/rails/action_controller_instruments.rb

@@ -1,23 +1,25 @@
-module ScoutApm::Instruments
-  module ActionControllerInstruments
-    def self.included(instrumented_class)
-      ScoutApm::Agent.instance.logger.debug "Instrumenting #{instrumented_class.inspect}"
-      instrumented_class.class_eval do
-        unless instrumented_class.method_defined?(:perform_action_without_scout_instruments)
-          alias_method :perform_action_without_scout_instruments, :perform_action
-          alias_method :perform_action, :perform_action_with_scout_instruments
-          private :perform_action
+module ScoutApm
+  module Instruments
+    module ActionControllerInstruments
+      def self.included(instrumented_class)
+        ScoutApm::Agent.instance.logger.debug "Instrumenting #{instrumented_class.inspect}"
+        instrumented_class.class_eval do
+          unless instrumented_class.method_defined?(:perform_action_without_scout_instruments)
+            alias_method :perform_action_without_scout_instruments, :perform_action
+            alias_method :perform_action, :perform_action_with_scout_instruments
+            private :perform_action
+          end
         end
       end
-    end # self.included
-    
-    # In addition to instrumenting actions, this also sets the scope to the controller action name. The scope is later
-    # applied to metrics recorded during this transaction. This lets us associate ActiveRecord calls with 
-    # specific controller actions.
-    def perform_action_with_scout_instruments(*args, &block)
-      scout_controller_action = "Controller/#{controller_path}/#{action_name}"
-      self.class.scout_apm_trace(scout_controller_action, :uri => request.request_uri, :ip => request.remote_ip) do
-        perform_action_without_scout_instruments(*args, &block)
+
+      # In addition to instrumenting actions, this also sets the scope to the controller action name. The scope is later
+      # applied to metrics recorded during this transaction. This lets us associate ActiveRecord calls with
+      # specific controller actions.
+      def perform_action_with_scout_instruments(*args, &block)
+        scout_controller_action = "Controller/#{controller_path}/#{action_name}"
+        self.class.scout_apm_trace(scout_controller_action, :uri => request.request_uri, :ip => request.remote_ip) do
+          perform_action_without_scout_instruments(*args, &block)
+        end
       end
     end
   end

data/lib/scout_apm/instruments/rails3_or_4/action_controller_instruments.rb

@@ -1,18 +1,20 @@
 # Rails 3/4
-module ScoutApm::Instruments
-  module ActionControllerInstruments
-    # Instruments the action and tracks errors.
-    def process_action(*args)
-      scout_controller_action = "Controller/#{controller_path}/#{action_name}"
-      #ScoutApm::Agent.instance.logger.debug "Processing #{scout_controller_action}"
-      self.class.scout_apm_trace(scout_controller_action, :uri => request.fullpath, :ip => request.remote_ip) do
-        begin
-          super
-        rescue Exception => e
-          ScoutApm::Agent.instance.store.track!("Errors/Request",1, :scope => nil)
-          raise
-        ensure
-          Thread::current[:scout_apm_scope_name] = nil
+module ScoutApm
+  module Instruments
+    module ActionControllerInstruments
+      # Instruments the action and tracks errors.
+      def process_action(*args)
+        scout_controller_action = "Controller/#{controller_path}/#{action_name}"
+
+        self.class.scout_apm_trace(scout_controller_action, :uri => request.fullpath, :ip => request.remote_ip) do
+          begin
+            super
+          rescue Exception
+            ScoutApm::Agent.instance.store.track!("Errors/Request",1, :scope => nil)
+            raise
+          ensure
+            Thread::current[:scout_apm_scope_name] = nil
+          end
         end
       end
     end
@@ -36,3 +38,4 @@ if defined?(ActionView) && defined?(ActionView::PartialRenderer)
     instrument_method :render_partial, :metric_name => 'View/#{@template.virtual_path}/Rendering', :scope => true
   end
 end
+

data/lib/scout_apm/layaway.rb

@@ -1,7 +1,7 @@
 # Stores metrics in a file before sending them to the server. Two uses:
 # 1. A centralized store for multiple Agent processes. This way, only 1 checkin is sent to Scout rather than 1 per-process.
 # 2. Bundling up reports from multiple timeslices to make updates more efficent server-side.
-# 
+#
 # Data is stored in a Hash, where the keys are Time.to_i on the minute. The value is a Hash {:metrics => Hash, :slow_transactions => Array}.
 # When depositing data, the new data is either merged with an existing time or placed in a new key.
 class ScoutApm::Layaway
@@ -9,7 +9,7 @@ class ScoutApm::Layaway
   def initialize
     @file = ScoutApm::LayawayFile.new
   end
-  
+
   def deposit_and_deliver
     new_metrics = ScoutApm::Agent.instance.store.metric_hash
     log_deposited_metrics(new_metrics)
@@ -18,14 +18,14 @@ class ScoutApm::Layaway
     file.read_and_write do |old_data|
       old_data ||= Hash.new
       # merge data
-      # if (1) there's data in the file and (2) there isn't any data yet for the current minute, this means we've 
+      # if (1) there's data in the file and (2) there isn't any data yet for the current minute, this means we've
       # collected all metrics for the previous slots and we're ready to deliver.
       #
       # Example w/2 processes:
       #
       # 12:00:34 ---
       # Process 1: old_data.any? => false, so deposits.
-      # Process 2: old_data_any? => true and old_data[12:00].nil? => false, so deposits. 
+      # Process 2: old_data_any? => true and old_data[12:00].nil? => false, so deposits.
       #
       # 12:01:34 ---
       # Process 1: old_data.any? => true and old_data[12:01].nil? => true, so delivers metrics.
@@ -44,11 +44,11 @@ class ScoutApm::Layaway
     end
     to_deliver.any? ? validate_data(to_deliver) : {}
   end
-  
-  # Ensures the data we're sending to the server isn't stale. 
-  # This can occur if the agent is collecting data, and app server goes down w/data in the local storage. 
+
+  # Ensures the data we're sending to the server isn't stale.
+  # This can occur if the agent is collecting data, and app server goes down w/data in the local storage.
   # When it is restarted later data will remain in local storage but it won't be for the current reporting interval.
-  # 
+  #
   # If the data is stale, an empty Hash is returned. Otherwise, the data from the most recent slot is returned.
   def validate_data(data)
     data = data.to_a.sort
@@ -63,14 +63,14 @@ class ScoutApm::Layaway
     ScoutApm::Agent.instance.logger.debug $!.message
     ScoutApm::Agent.instance.logger.debug $!.backtrace
   end
-  
+
   # Data is stored under timestamp-keys (without the second).
   def slot
     t = Time.now
     t -= t.sec
     t.to_i
   end
-  
+
   def log_deposited_metrics(new_metrics)
     controller_count = 0
     new_metrics.each do |meta,stats|
@@ -84,7 +84,7 @@ class ScoutApm::Layaway
   def log_deposited_slow_transactions(new_slow_transactions)
     ScoutApm::Agent.instance.logger.debug "Depositing #{new_slow_transactions.size} slow transactions into #{Time.at(slot).strftime("%m/%d/%y %H:%M:%S %z")} slot."
   end
-  
+
   def log_saved_data(old_data,new_metrics)
     ScoutApm::Agent.instance.logger.debug "Saving the following #{old_data.size} time slots locally:"
     old_data.each do |k,v|
@@ -97,4 +97,4 @@ class ScoutApm::Layaway
       ScoutApm::Agent.instance.logger.debug "#{Time.at(k).strftime("%m/%d/%y %H:%M:%S %z")} => #{controller_count} requests and #{v[:slow_transactions].size} slow transactions"
     end
   end
-end
+end