copperegg-apm 1.0.0.pre1

data/lib/copperegg/apm.rb

@@ -0,0 +1,28 @@
+at_exit do
+  begin
+    CopperEgg::APM.send_payload_cache
+  rescue
+  end
+end
+
+%w(
+  benchmark
+  action_controller/base
+  active_record/connection_adapters/abstract_adapter
+  configuration
+  errors
+  ethon/easy/operations
+  kernel
+  mysql
+  mysql2/client 
+  net/http
+  pg/connection 
+  restclient/request
+  rum
+  sqlite3/database
+  typhoeus/hydra
+  unbound_method
+  version
+).each { |file| require "copperegg/apm/#{file}" }
+
+require 'copperegg/apm/engine' if defined?(::Rails::Engine)

data/lib/copperegg/apm/action_controller/base.rb

@@ -0,0 +1,31 @@
+module CopperEgg
+  module APM
+    module ActionController
+      module Base
+        def self.included(klass)
+          klass.class_eval do
+            def self.add_benchmarks(options={})
+              raise ArgumentError.new("hash expected") if !options.is_a?(Hash)
+              around_filter :ce_benchmark_controller_actions, options
+            end
+
+            def ce_benchmark_controller_actions
+              starttime = (Time.now.to_f * 1000.0).to_i
+              yield
+              time = (Time.now.to_f * 1000.0).to_i - starttime
+              CopperEgg::APM.send_payload({:method => "#{self.to_s.sub!(/:[a-z0-9]x[^>]+>/, "").sub!("#<","")}##{action_name}", :time => time})
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined?(::ActionController::Base)
+
+  class ActionController::Base
+    include CopperEgg::APM::ActionController::Base
+  end
+
+end

data/lib/copperegg/apm/active_record/connection_adapters/abstract_adapter.rb

@@ -0,0 +1,35 @@
+module CopperEgg
+  module APM
+    module ActiveRecord
+      module ConnectionAdapters
+        module AbstractAdapter
+          def log_with_ce_instrumentation(*args)
+            if CopperEgg::APM::Configuration.benchmark_active_record?
+              sql, name = args
+              starttime = (Time.now.to_f * 1000.0).to_i
+              result = block_given? ? log_without_ce_instrumentation(*args, &Proc.new) : log_without_ce_instrumentation(*args)
+              time = (Time.now.to_f * 1000.0).to_i - starttime
+
+              CopperEgg::APM.send_payload({:sql => CopperEgg::APM.obfuscate_sql(sql), :time => time})
+                
+              result
+            else
+              block_given? ? log_without_ce_instrumentation(*args, &Proc.new) : log_without_ce_instrumentation(*args)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+if defined?(::ActiveRecord) && ::ActiveRecord::VERSION::MAJOR >= 3
+
+  class ActiveRecord::ConnectionAdapters::AbstractAdapter
+    include CopperEgg::APM::ActiveRecord::ConnectionAdapters::AbstractAdapter
+    alias_method :log_without_ce_instrumentation, :log
+    alias_method :log, :log_with_ce_instrumentation
+    protected :log
+  end
+
+end

data/lib/copperegg/apm/benchmark.rb

@@ -0,0 +1,212 @@
+require 'socket'
+require 'json'
+
+module CopperEgg
+  module APM
+    DO_NOT_INCLUDE_PATHS = %w(. test spec vendor config)
+    PAYLOAD_FREQUENCY = 15
+    PAYLOAD_BYTESIZE = 1024*8
+    @@benchmarkable_methods = []
+    @@payload_sent_at = 0
+    @@payload_cache = ""
+    @@gem_version_sent = false
+
+    module_function
+
+    def configure(&block)
+      @@payload_cache = {:version => CopperEgg::APM::GEM_VERSION}.to_json
+      send_payload_cache
+      Configuration.configure(&block)
+    end
+        
+    def benchmark(arg, &block)
+      if arg.class == Hash
+        parameters = arg
+      elsif arg.class == Class || arg.class == Module
+        parameters = {:method => "#{arg}.#{calling_method}"}
+      else
+        parameters = {:method => "#{arg.class}##{calling_method}"}
+      end
+
+      starttime = (Time.now.to_f * 1000.0).to_i
+      result = yield
+      parameters[:time] = (Time.now.to_f * 1000.0).to_i - starttime
+
+      send_payload(parameters)
+      
+      result
+    end
+
+    # Inject benchmarking code into user-defined public instance and class accessor methods whose names are made up of only alphanumeric characters.
+    # By user-defined, we mean those whose source is defined in neither the load path nor the gem path.
+    def add_method_benchmarking
+      benchmarkable_methods.each {|method| method.add_benchmarking unless method.excluded?}
+    end
+
+    # Returns an array of unbound methods to which benchmarking can be added.
+    def benchmarkable_methods
+      return @@benchmarkable_methods if @@benchmarkable_methods.size > 0
+
+      if defined?(::Rails) && Rails.respond_to?(:configuration)
+        $LOAD_PATH.each do |path|
+          v, $VERBOSE = $VERBOSE, nil
+          if path.include?(Rails.configuration.root.to_s) && DO_NOT_INCLUDE_PATHS.detect {|part| path.include?("/#{part}")}.nil?
+            Dir.glob("#{path}/**/*.rb").each {|f| ActiveSupport::Dependencies::Loadable.require_dependency f, ""}
+          end
+          $VERBOSE = v
+        end
+      end
+      
+      ObjectSpace.each_object(Class) do |class_or_module|
+        begin
+          class_or_module.instance_methods(false).each do |name|
+            method = class_or_module.instance_method(name)
+            method.parent_class = class_or_module
+            @@benchmarkable_methods.push(method) if method.benchmarkable?
+          end
+        rescue
+        end
+
+        begin
+          class_or_module.singleton_class.instance_methods(false).each do |name|
+            method = class_or_module.singleton_class.instance_method(name)
+            method.parent_class = class_or_module
+            method.class_method = true
+            @@benchmarkable_methods.push(method) if method.benchmarkable?
+          end
+        rescue
+        end
+      end
+
+      @@benchmarkable_methods
+    end
+
+    def send_payload(parameters)
+      return if CopperEgg::APM::Configuration.instrument_key == nil
+
+      param_type =  if parameters.has_key?(:sql)
+                      :sql
+                    elsif parameters.has_key?(:method)
+                      :method
+                    elsif parameters.has_key?(:url)
+                      :url
+                    elsif parameters.has_key?(:error)
+                      :error
+                    end
+
+      parameters[param_type] += " {Ruby}"
+
+      key = parameters[:error] ? :excp : :inst
+      hash = {key => parameters, :id => CopperEgg::APM::Configuration.instrument_key}
+
+      json = hash.to_json
+      payload = "#{[0x6375].pack("N")}#{[json.length].pack("N")}#{json}"
+      if @@payload_cache.bytesize > PAYLOAD_BYTESIZE
+        @@payload_cache = ""
+      elsif @@payload_cache.bytesize > 0 && ((@@payload_cache.bytesize + payload.bytesize) >= PAYLOAD_BYTESIZE || Time.now.to_i - @@payload_sent_at >= PAYLOAD_FREQUENCY)
+        send_payload_cache
+      end
+      @@payload_cache = "#{@@payload_cache}#{payload}"
+    end
+
+    def send_payload_cache
+      begin
+        if RUBY_VERSION < "1.9"
+          socket = UDPSocket.new
+          socket.send(@@payload_cache, 0, CopperEgg::APM::Configuration.udp_host, CopperEgg::APM::Configuration.udp_port)
+        else
+          socket = Socket.new(:INET, :DGRAM)
+          addr = Socket.sockaddr_in(CopperEgg::APM::Configuration.udp_port, CopperEgg::APM::Configuration.udp_host)
+          socket.connect_nonblock(addr)
+          socket.send(@@payload_cache, 0)
+        end
+      rescue Errno::EMSGSIZE
+      end
+      socket.close
+      CopperEgg::APM::Configuration.log @@payload_cache
+      @@payload_sent_at = Time.now.to_i
+      @@payload_cache = ""
+    end
+
+    # Returns a copy of self with escaping, quotes, whitespacing and actual values removed
+    # from SQL statements
+    def obfuscate_sql(sql)
+      return sql if sql.bytesize > 1024 # don't bother with sql statements larger than 1k
+      sql = sql.dup
+
+      # Remove escaping quotes
+      sql.gsub!(/\\["']/, '')
+    
+      # Remove surrounding backticks
+      sql.gsub!(/[`]([^`]+)[`]/i,'\1')
+
+      # Remove surrounding quotes from strings immediately following "FROM"
+      sql.gsub!(/(from|into|update|set)\s*['"`]([^'"`]+)['"`]/i,'\1 \2')
+
+      # Remove surrounding quotes from strings immediately neighboring a period
+      sql.gsub!(/([\.])['"]([^'"]+)['"]/,'\1\2')
+      sql.gsub!(/['"]([^'"]+)['"]([\.])/,'\1\2')
+
+      # Replace other quoted strings with a question mark
+      sql.gsub!(/['"]([^'"]+)['"]/,'?')
+
+      # Remove integers
+      sql.gsub!(/\b\d+\b/, '?')
+
+      # Removing padded spaces
+      sql.gsub!(/(\s){2,}/,'\1')
+
+      # Remove leading and trailing whitespace
+      sql.strip!
+
+      sql
+    end
+
+    def trim_stacktrace(array)
+      previous_components = nil
+
+      last = array.last.strip
+
+      array.reject! {|path| path.include? CopperEgg::APM::Configuration.gem_root}
+
+      if !CopperEgg::APM::Configuration.app_root.empty?
+        array.reject! {|path| !path.include?(CopperEgg::APM::Configuration.app_root) || !CopperEgg::APM::DO_NOT_INCLUDE_PATHS.detect {|part| path.include?("/#{part}")}.nil?}
+      end
+
+      array.map! do |path|
+        if previous_components
+          current_components = path.split("/")
+
+          if (current_components - previous_components).size == 1
+            path = ".../" + (current_components - previous_components).join("/")
+          end
+
+          previous_components = current_components
+        else
+          previous_components = path.split("/")
+        end
+        path.strip
+      end
+
+      array.push(last) if last && array.empty?
+      array
+    end
+
+    def calling_method
+      caller[1] =~ /`([^']*)'/ and $1
+    end
+
+    def capture_exception(*args)
+      exception = if args.size == 0
+        $!.nil? ? RuntimeError.new : $!        
+      elsif args.size == 1
+        args.first.is_a?(String) ? RuntimeError.exception(args.first) : args.first.exception
+      elsif args.size <= 3
+        args.first.exception(args[1])
+      end
+      stacktrace = trim_stacktrace(caller)
+      parameters = {:error => "#{exception.class}|#{stacktrace.first}", :stacktrace => "#{exception.message}\n#{stacktrace.join("\n")}", :ts => Time.now.to_i}
+      send_payload(parameters)
+    end
+  end
+end

data/lib/copperegg/apm/benchmark_methods_table.rb

@@ -0,0 +1,65 @@
+module CopperEgg
+  module APM
+    class BenchmarkMethodsTable
+      def benchmarkable_methods
+        @benchmarkable_methods ||= CopperEgg::APM.benchmarkable_methods.sort_by(&:display_name)
+      end
+
+      def excluded_methods
+        benchmarkable_methods.select {|method| method.excluded?}
+      end
+
+      def method_column_width
+        benchmarkable_methods.reduce(0) do |memo, method|
+          method.display_name.size > memo ? method.display_name.size : memo
+        end + column_padding
+      end
+
+      def source_filename_column_width
+        benchmarkable_methods.reduce(0) do |memo, method|
+          method.display_filename.size > memo ? method.display_filename.size : memo
+        end + column_padding
+      end
+
+      def column_padding
+        2
+      end
+
+      def separator
+        "+" + "-"*(method_column_width+1) + "+" + "-"*(source_filename_column_width+1) + "+" + "--------------+"
+      end
+
+      def header_columns
+        "| Method" + " "*(method_column_width - 6).abs + "| Source Location" + " "*(source_filename_column_width - 15).abs + "| Benchmarked? |"
+      end
+
+      def method_columns(method)
+        "| #{method.display_name}" + " "*(method_column_width - method.display_name.size) + "| #{method.display_filename}" + " "*(source_filename_column_width - method.display_filename.size) + "| #{method.excluded? ? "NO " : "YES"}          |"
+      end
+
+      def classes_count
+        benchmarkable_methods.map(&:owner).uniq!.size
+      end
+
+      def file_count
+        benchmarkable_methods.map(&:source_filename).uniq!.size
+      end
+
+      def print_table
+        if RUBY_VERSION < "1.9"
+          puts "Method benchmarking is not available in Ruby #{RUBY_VERSION}. It is only available in Ruby 1.9 or later."
+        elsif CopperEgg::APM::Configuration.benchmark_methods_level == :disabled
+          puts "Method benchmarking is disabled. You can enable method benchmarking by setting the benchmark_methods configuration value."
+        elsif benchmarkable_methods.size == 0
+          puts "No methods benchmarked"
+        else
+          puts
+          puts "#{separator}\n#{header_columns}\n#{separator}\n#{benchmarkable_methods.map {|method| method_columns(method)}.join("\n")}\n#{separator}"
+          puts "#{benchmarkable_methods.size} methods defined in #{classes_count} classes across #{file_count} files. #{benchmarkable_methods.size - excluded_methods.size == 1 ? "1 method" : "#{benchmarkable_methods.size - excluded_methods.size} methods"} benchmarked."
+          puts
+        end
+      end
+
+    end
+  end
+end

data/lib/copperegg/apm/configuration.rb

@@ -0,0 +1,188 @@
+require 'logger'
+require 'date'
+require 'set'
+
+module CopperEgg
+  module APM
+    class Configuration
+      BENCHMARK_METHOD_LEVELS = [:disabled, :basic, :moderate, :full, :custom]
+
+      @@udp_port                  = 28344
+      @@udp_host                  = "127.0.0.1"
+      @@app_root                  = ""
+      @@instrument_key            = nil
+      @@rum_short_url             = false
+      @@rum_beacon_url            = "http://bacon.copperegg.com/bacon.gif"
+      @@gem_root                  = File.dirname(File.dirname(__FILE__))
+      @@log_to                    = nil
+      @@benchmark_sql             = true
+      @@benchmark_active_record   = false
+      @@benchmark_http            = true
+      @@benchmark_exceptions      = true
+      @@benchmark_methods_level   = :disabled
+      @@only_methods              = []
+      @@exclude_methods           = []
+      @@include_methods           = []
+      @@logger                    = nil
+
+      def self.udp_port
+        @@udp_port
+      end
+
+      def self.udp_host
+        @@udp_host
+      end
+
+      def self.rum_beacon_url
+        @@rum_beacon_url
+      end
+
+      def self.gem_root
+        @@gem_root
+      end
+
+      def self.instrument_key=(key)
+        raise ConfigurationError.new("invalid instrument key") if !key =~ /\A[a-z0-9]+\z/i
+        @@instrument_key = key
+        create_logfile if @@log_to
+      end
+
+      def self.instrument_key
+        @@instrument_key
+      end
+
+      def self.rum_short_url=(boolean)
+        raise ConfigurationError.new("RUM short url must be a boolean") if boolean != true && boolean != false
+        @@rum_short_url = boolean
+      end
+
+      def self.rum_short_url
+        @@rum_short_url
+      end
+
+      def self.app_root=(path)
+        @@app_root = path.to_s
+      end
+
+      def self.app_root
+        @@app_root
+      end
+
+      def self.benchmark_sql=(boolean)
+        raise ConfigurationError.new("Boolean expected for benchmark_sql") if boolean != true && boolean != false
+        @@benchmark_sql = boolean
+      end
+
+      def self.benchmark_sql?
+        @@benchmark_sql
+      end
+
+      def self.benchmark_active_record=(boolean)
+        raise ConfigurationError.new("Boolean expected for benchmark_active_record") if boolean != true && boolean != false
+        @@benchmark_sql = boolean
+      end
+
+      def self.benchmark_active_record?
+        @@benchmark_active_record
+      end      
+
+      def self.benchmark_http=(boolean)
+        raise ConfigurationError.new("Boolean expected for benchmark_http") if boolean != true && boolean != false
+        @@benchmark_http = boolean
+      end
+
+      def self.benchmark_http?
+        @@benchmark_http
+      end
+
+      def self.benchmark_exceptions=(boolean)
+        raise ConfigurationError.new("Boolean expected for benchmark_exceptions") if boolean != true && boolean != false
+        @@benchmark_exceptions = boolean
+      end
+
+      def self.benchmark_exceptions?
+        @@benchmark_exceptions
+      end
+
+      def self.benchmark_methods(level, options={})
+        raise ConfigurationError.new("Method benchmark level can only be :disabled, :basic, :moderate, :full, or :custom") if !BENCHMARK_METHOD_LEVELS.include?(level)
+
+        @@benchmark_methods_level = level        
+        return if level == :disabled
+
+        if level == :custom
+          benchmark_methods_option(options, :@@only_methods)
+        else
+          benchmark_methods_option(options[:include], :@@include_methods) if options[:include]
+          benchmark_methods_option(options[:exclude], :@@exclude_methods) if options[:exclude]
+        end
+      end
+
+      def self.benchmark_methods_level
+        @@benchmark_methods_level
+      end
+
+      def self.only_methods
+        @@only_methods || []
+      end
+
+      def self.include_methods
+        @@include_methods || []
+      end
+
+      def self.exclude_methods
+        @@exclude_methods || []
+      end
+
+      def self.log(payload)
+        return if @@logger == nil
+        @@logger.debug "Payload sent at #{DateTime.strptime(Time.now.to_i.to_s, '%s').strftime('%Y-%m-%d %H:%M:%S')} #{payload.bytesize} bytes\n"
+        @@logger.debug payload.split("\x00").select {|i| i.size > 2}.map {|i| i.sub(/^[^\{]+/,'')}.join("\n")
+        @@logger.debug ""
+      end
+
+      def self.enable_logging=(boolean)
+        raise ConfigurationError.new("Boolean expected for logging_enabled") if boolean != true && boolean != false
+        dir = '/tmp'
+        raise ConfigurationError.new("Directory #{dir} must be readable and writable.") if !File.readable?(dir) || !File.writable?(dir)
+        @@log_to = dir
+        if @@instrument_key
+          create_logfile
+        end
+      end
+
+      def self.configure(&block)
+        yield(self)
+
+        if @@app_root.empty?
+          if defined?(::Rails) && ::Rails.respond_to?(:configuration)
+            @@app_root = ::Rails.configuration.root.to_s
+          else
+            @@app_root = File.dirname(caller[1])
+          end
+        end
+
+        CopperEgg::APM.add_method_benchmarking if @@benchmark_methods_level != :disabled
+      end
+
+      class <<self
+        private
+
+        def benchmark_methods_option(array, class_variable_name)
+          raise ConfigurationError.new("Array expected for benchmark method option") if !array.is_a?(Array)
+          array.each do |value|
+            raise ConfigurationError.new("Invalid item #{value} in benchmark method option. String expected.") if !value.is_a?(String)
+          end
+          class_variable_set(class_variable_name, array)
+        end
+
+        def create_logfile
+          logdir = File.join(@@log_to, 'copperegg', 'apm')
+          FileUtils.mkdir_p(logdir) unless File.directory?(logdir)
+
+          @@logger = Logger.new(File.join(logdir, "#{@@instrument_key}.log"), 0)
+        end
+      end
+    end
+  end
+end