oneapm_rpm 1.1.0

data/lib/one_apm/metrics/stats.rb

@@ -0,0 +1,173 @@
+# encoding: utf-8
+module OneApm
+  module Metrics
+    class Stats
+
+      attr_accessor :call_count
+      attr_accessor :min_call_time
+      attr_accessor :max_call_time
+      attr_accessor :total_call_time
+      attr_accessor :total_exclusive_time
+      attr_accessor :sum_of_squares
+
+      def self.create_from_hash hash_value
+        stats = Stats.new
+        stats.call_count           = hash_value[:count] if hash_value[:count]
+        stats.total_call_time      = hash_value[:total] if hash_value[:total]
+        stats.total_exclusive_time = hash_value[:total] if hash_value[:total]
+        stats.min_call_time        = hash_value[:min] if hash_value[:min]
+        stats.max_call_time        = hash_value[:max] if hash_value[:max]
+        stats.sum_of_squares       = hash_value[:sum_of_squares] if hash_value[:sum_of_squares]
+        stats
+      end
+
+      def initialize
+        reset
+      end
+
+      def reset
+        @call_count = 0
+        @total_call_time = 0.0
+        @total_exclusive_time = 0.0
+        @min_call_time = 0.0
+        @max_call_time = 0.0
+        @sum_of_squares = 0.0
+      end
+
+      def is_reset?
+        call_count == 0 && total_call_time == 0.0 && total_exclusive_time == 0.0
+      end
+
+      def merge(other_stats)
+        stats = self.clone
+        stats.merge!(other_stats)
+      end
+
+      def merge!(other)
+        @min_call_time = other.min_call_time if min_time_less?(other)
+        @max_call_time = other.max_call_time if other.max_call_time > max_call_time
+        @total_call_time      += other.total_call_time
+        @total_exclusive_time += other.total_exclusive_time
+        @sum_of_squares       += other.sum_of_squares
+        @call_count += other.call_count
+        self
+      end
+
+      def to_s
+        "[#{'%2i' % call_count.to_i} calls #{'%.4f' % total_call_time.to_f}s / #{'%.4f' % total_exclusive_time.to_f}s ex]"
+      end
+
+      def to_json(*_)
+        {
+          'call_count'           => call_count.to_i,
+          'min_call_time'        => min_call_time.to_f,
+          'max_call_time'        => max_call_time.to_f,
+          'total_call_time'      => total_call_time.to_f,
+          'total_exclusive_time' => total_exclusive_time.to_f,
+          'sum_of_squares'       => sum_of_squares.to_f
+        }.to_json(*_)
+      end
+
+      def record(value=nil, aux=nil, &blk)
+        if blk
+          yield self
+        else
+          case value
+          when Numeric
+            aux ||= value
+            self.record_data_point(value, aux)
+          when :apdex_s, :apdex_t, :apdex_f
+            self.record_apdex(value, aux)
+          when OneApm::Metrics::Stats
+            self.merge!(value)
+          end
+        end
+      end
+
+      # record a single data point into the statistical gatherer.  The gatherer
+      # will aggregate all data points collected over a specified period and upload
+      # its data to the OneApm server
+      def record_data_point(value, exclusive_time = value)
+        @call_count += 1
+        @min_call_time = value if value < @min_call_time || @call_count == 1
+        @max_call_time = value if value > @max_call_time
+        @total_call_time += value
+        @total_exclusive_time += exclusive_time
+
+        @sum_of_squares += (value * value)
+        self
+      end
+
+      alias trace_call record_data_point
+
+      # increments the call_count by one
+      def increment_count(value = 1)
+        @call_count += value
+      end
+
+      def inspect
+        "#<OneApm::Metrics::Stats #{to_s} >"
+      end
+
+      # Concerned about implicit usage of inspect relying on stats format, so
+      # putting back a version to get full inspection as separate method
+      def inspect_full
+        variables = instance_variables.map do |ivar|
+          "#{ivar.to_s}=#{instance_variable_get(ivar).inspect}"
+        end.join(" ")
+        "#<OneApm::Metrics::Stats #{variables}>"
+      end
+
+      def ==(other)
+        other.class == self.class &&
+        (
+          @min_call_time        == other.min_call_time &&
+          @max_call_time        == other.max_call_time &&
+          @total_call_time      == other.total_call_time &&
+          @total_exclusive_time == other.total_exclusive_time &&
+          @sum_of_squares       == other.sum_of_squares &&
+          @call_count           == other.call_count
+        )
+      end
+
+      # Apdex-related accessors
+      alias_method :apdex_s, :call_count
+      alias_method :apdex_t, :total_call_time
+      alias_method :apdex_f, :total_exclusive_time
+
+      def record_apdex(bucket, apdex_t)
+        case bucket
+        when :apdex_s then @call_count += 1
+        when :apdex_t then @total_call_time += 1
+        when :apdex_f then @total_exclusive_time += 1
+        end
+        if apdex_t
+          @min_call_time = apdex_t
+          @max_call_time = apdex_t
+        else
+          ::OneApm::Agent.logger.warn("Attempted to set apdex_t to #{apdex_t.inspect}, backtrace = #{caller.join("\n")}")
+        end
+      end
+
+      protected
+
+      def min_time_less?(other)
+        (other.min_call_time < min_call_time && other.call_count > 0) || call_count == 0
+      end
+    end
+
+    class ChainedStats
+      attr_accessor :scoped_stats, :unscoped_stats
+
+      def initialize(scoped_stats, unscoped_stats)
+        @scoped_stats = scoped_stats
+        @unscoped_stats = unscoped_stats
+      end
+
+      def method_missing(method, *args)
+        unscoped_stats.send(method, *args)
+        scoped_stats.send(method, *args)
+      end
+    end
+  end
+end

data/lib/one_apm/probe.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'one_apm/support/local_environment'
+require 'one_apm/support/language_support'
+require 'one_apm/support/helper'
+require 'one_apm/support/version_number'
+
+require 'one_apm/probe/framework_loader'
+require 'one_apm/probe/instrumentation'
+require 'one_apm/probe/instance_methods'
+
+require 'one_apm/agent'
+
+module OneApm
+  class Probe; end
+end

data/lib/one_apm/probe/framework_loader.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module OneApm
+  class Probe
+    module FrameworkLoader
+
+      def init(options = {})
+        instance.init_plugin options
+      end
+
+      def instance
+        @instance ||= new_instance
+      end
+
+      def new_instance
+        if Agent.config[:framework] == :test
+          load_test_framework
+        else
+          load_framework_class(Agent.config[:framework]).new(local_env)
+        end
+      end
+
+      def reset
+        @instance = nil
+        @local_env = nil
+      end
+
+      def local_env
+        @local_env ||= OneApm::LocalEnvironment.new
+      end
+
+      def load_test_framework
+        config = File.expand_path(File.join('..', '..', '..', '..', 'test', 'config', 'oneapm.yml'), __FILE__)
+        require 'config/test_control'
+        OneApm::Probe::Frameworks::Test.new(local_env, config)
+      end
+
+      def load_framework_class(framework)
+        begin
+          require "one_apm/frameworks/#{framework}"
+        rescue LoadError
+        end
+        OneApm::Probe::Frameworks.const_get(framework.to_s.capitalize)
+      end
+
+      def oneapm_root
+        File.expand_path(File.join('..', '..', '..', '..'), __FILE__)
+      end
+    end
+
+    extend FrameworkLoader
+  end
+end

data/lib/one_apm/probe/instance_methods.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+
+require 'one_apm/logger/null_logger'
+require 'one_apm/logger/memory_logger'
+require 'one_apm/logger/agent_logger'
+
+module OneApm
+  class Probe
+    module InstanceMethods
+
+      attr_writer :env
+      attr_reader :local_env
+
+      def init_plugin(options = {})
+        env = options[:env] || self.env
+
+        Agent.logger.info("Starting the OneApm agent in #{env.inspect} environment.")
+
+        configure_agent(env, options)
+
+        # Be sure to only create once! RUBY-1020
+        if ::OneApm::Agent.logger.is_startup_logger?
+          ::OneApm::Agent.logger = OneApm::Agent::AgentLogger.new(root, options.delete(:log))
+        end
+
+        # Merge the stringified options into the config as overrides:
+        environment_name = options.delete(:env) and self.env = environment_name
+
+        OneApm::Agent::PipeChannelManager.listener.start if options.delete(:start_channel_listener)
+
+        # An artifact of earlier implementation, we put both #add_method_tracer and #trace_execution
+        # methods in the module methods.
+        Module.send :include, OneApm::Support::MethodTracer::ClassMethods
+        Module.send :include, OneApm::Support::MethodTracer
+
+        init_config(options)
+
+        # initialize agent
+        OneApm::Agent.instance = OneApm::Agent::Agent.instance
+        OneApm::Agent.instance.start_service_if_needed
+
+        if Agent.config[:agent_enabled] && !OneApm::Agent.instance.started?
+          start_agent
+          install_instrumentation
+        elsif !Agent.config[:agent_enabled]
+          install_shim
+        else
+          detect_dependencies
+        end
+      end
+
+      def configure_agent(env, options)
+        manual = OneApm::Configuration::ManualSource.new(options)
+        Agent.config.replace_or_add_config(manual)
+
+        config_file_path = @config_file_override || Agent.config[:config_path]
+        Agent.config.replace_or_add_config(OneApm::Configuration::YamlSource.new(config_file_path, env))
+
+        if Agent.config[:high_security]
+          Agent.logger.info("Installing high security configuration based on local configuration")
+          Agent.config.replace_or_add_config(OneApm::Configuration::HighSecuritySource.new(Agent.config))
+        end
+      end
+
+      # Install the real agent into the Agent module, and issue the start command.
+      def start_agent
+        OneApm::Agent.instance.start
+      end
+
+      def app
+        Agent.config[:framework]
+      end
+
+      def framework
+        Agent.config[:framework]
+      end
+
+      def settings
+        OneApm::Agent.config.to_collector_hash
+      end
+
+      def dispatcher
+        OneApm::Agent.config[:dispatcher]
+      end
+
+      def oneapm_root
+        OneApm::Probe.oneapm_root
+      end
+
+      protected
+
+      def initialize(local_env, config_file_override = nil)
+        @local_env = local_env
+        @instrumentation_files = []
+        @config_file_override = config_file_override
+      end
+
+      def root
+        '.'
+      end
+
+    end
+    include InstanceMethods
+  end
+end

data/lib/one_apm/probe/instrumentation.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+require 'one_apm/support/library_detection'
+
+module OneApm
+  class Probe
+    module Instrumentation
+
+      # install instrumentations for the current framework
+      def install_instrumentation
+        return if @instrumented
+
+        @instrumented = true
+
+        # Instrumentation for the key code points inside rails for monitoring by OneApm.
+        # note this file is loaded only if the oneapm agent is enabled (through config/oneapm.yml)
+        instrumentation_path = File.expand_path(File.join(File.dirname(__FILE__), '..', 'inst'))
+        Dir.glob("#{instrumentation_path}/**/*.rb").each do |inst_file|
+          load_instrumentation_files inst_file
+        end
+        detect_dependencies
+        OneApm::Agent.logger.info "Finished instrumentation"
+      end
+
+      def load_instrumentation_files pattern
+        Dir.glob(pattern) { |file| require_instrumentation(file.to_s) }
+      end
+
+      def detect_dependencies
+        LibraryDetection.detect!
+      end
+
+      # require specified instrumentation
+      def require_instrumentation file
+        require file
+      rescue => e
+        ::OneApm::Agent.logger.warn "Error loading instrumentation file '#{file}':", e
+      end
+
+      def install_shim
+        # Once we install instrumentation, you can't undo that by installing the shim.
+        if @instrumented
+          OneApm::Agent.logger.error "Cannot install the Agent shim after instrumentation has already been installed!"
+          OneApm::Agent.logger.error caller.join("\n")
+        else
+          OneApm::Agent.instance = OneApm::Agent::ShimAgent.instance
+        end
+      end
+
+      def add_instrumentation pattern
+        if @instrumented
+          load_instrumentation_files pattern
+        else
+          @instrumentation_files << pattern
+        end
+      end
+    end
+    include Instrumentation
+  end
+end

data/lib/one_apm/rack/browser_monitoring.rb

@@ -0,0 +1,144 @@
+# encoding: utf-8
+
+require 'rack'
+require 'one_apm/rack/middleware_base'
+require 'one_apm/rack/middleware_wrapper'
+
+module OneApm::Rack
+  class BrowserMonitoring < MiddlewareBase
+
+    SCAN_LIMIT = 50_000
+    ALREADY_INSTRUMENTED_KEY = "oneapm.browser_monitoring_already_instrumented"
+
+    CHARSET_RE         = /<\s*meta[^>]+charset\s*=[^>]*>/im.freeze
+    X_UA_COMPATIBLE_RE = /<\s*meta[^>]+http-equiv\s*=\s*['"]x-ua-compatible['"][^>]*>/im.freeze
+
+    def traced_call(env)
+      result = @app.call(env)   # [status, headers, response]
+
+      js_to_inject = OneApm::Agent.browser_timing_header
+      if (js_to_inject != "") && should_instrument?(env, result[0], result[1])
+        response_string = autoinstrument_source(result[2], result[1], js_to_inject)
+
+        env[ALREADY_INSTRUMENTED_KEY] = true
+        if response_string
+          response = Rack::Response.new(response_string, result[0], result[1])
+          response.finish
+        else
+          result
+        end
+      else
+        result
+      end
+    end
+
+    def should_instrument?(env, status, headers)
+      OneApm::Agent.config[:'browser_monitoring.auto_instrument'] &&
+        status == 200 &&
+        !env[ALREADY_INSTRUMENTED_KEY] &&
+        is_html?(headers) &&
+        !is_attachment?(headers) &&
+        !is_streaming?(env)
+    end
+
+    def is_html?(headers)
+      headers["Content-Type"] && headers["Content-Type"].include?("text/html")
+    end
+
+    def is_attachment?(headers)
+      headers['Content-Disposition'].to_s.include?('attachment')
+    end
+
+    def is_streaming?(env)
+      return false unless defined?(ActionController::Live)
+
+      env['action_controller.instance'].class.included_modules.include?(ActionController::Live)
+    end
+
+    def autoinstrument_source(response, headers, js_to_inject)
+      source = gather_source(response)
+      close_old_response(response)
+      return nil unless source
+
+      # Only scan the first 50k (roughly) then give up.
+      beginning_of_source = source[0..SCAN_LIMIT]
+
+      if body_start = find_body_start(beginning_of_source)
+        meta_tag_positions = [
+          find_x_ua_compatible_position(beginning_of_source),
+          find_charset_position(beginning_of_source)
+        ].compact
+
+        if !meta_tag_positions.empty?
+          insertion_index = meta_tag_positions.max
+        else
+          insertion_index = find_end_of_head_open(beginning_of_source) || body_start
+        end
+
+        if insertion_index
+          source = source[0...insertion_index] <<
+            js_to_inject <<
+            source[insertion_index..-1]
+        else
+          OneApm::Agent.logger.debug "Skipping RUM instrumentation. Could not properly determine location to inject script."
+        end
+      else
+        msg = "Skipping RUM instrumentation. Unable to find <body> tag in first #{SCAN_LIMIT} bytes of document."
+        OneApm::Agent.logger.log_once(:warn, :rum_insertion_failure, msg)
+        OneApm::Agent.logger.debug(msg)
+      end
+
+      if headers['Content-Length']
+        headers['Content-Length'] = calculate_content_length(source).to_s
+      end
+
+      source
+    rescue => e
+      OneApm::Agent.logger.debug "Skipping RUM instrumentation on exception.", e
+      nil
+    end
+
+    def gather_source(response)
+      source = nil
+      response.each {|fragment| source ? (source << fragment.to_s) : (source = fragment.to_s)}
+      source
+    end
+
+    # Per "The Response > The Body" section of Rack spec, we should close
+    # if our response is able. http://rack.rubyforge.org/doc/SPEC.html
+    def close_old_response(response)
+      if response.respond_to?(:close)
+        response.close
+      end
+    end
+
+    def find_body_start(beginning_of_source)
+      beginning_of_source.index("<body")
+    end
+
+    def find_x_ua_compatible_position(beginning_of_source)
+      match = X_UA_COMPATIBLE_RE.match(beginning_of_source)
+      match.end(0) if match
+    end
+
+    def find_charset_position(beginning_of_source)
+      match = CHARSET_RE.match(beginning_of_source)
+      match.end(0) if match
+    end
+
+    def find_end_of_head_open(beginning_of_source)
+      head_open = beginning_of_source.index("<head")
+      beginning_of_source.index(">", head_open) + 1 if head_open
+    end
+
+    # String does not respond to 'bytesize' in 1.8.6. Fortunately String#length
+    # returns bytes rather than characters in 1.8.6 so we can use that instead.
+    def calculate_content_length(source)
+      if source.respond_to?(:bytesize)
+        source.bytesize
+      else
+        source.length
+      end
+    end
+  end
+end