oneapm_rpm 1.1.3 → 1.2.0

data/lib/one_apm/inst/nosql/redis.rb

@@ -14,7 +14,7 @@ LibraryDetection.defer do
   end
 
   executes do
-    require 'one_apm/agent/datastores'
+    require 'one_apm/agent/datastore'
 
     ::Redis::Client.class_eval do
       # Support older versions of Redis::Client that used the method
@@ -28,7 +28,7 @@ LibraryDetection.defer do
           _send_to_one_apm(args, elapsed)
         end
 
-        OneApm::Agent::Datastores.wrap("Redis", method_name, nil, callback) do
+        OneApm::Agent::Datastore.wrap("Redis", method_name, nil, callback) do
           call_without_oneapm_trace(*args, &blk)
         end
       end
@@ -57,7 +57,7 @@ LibraryDetection.defer do
             end
           end
 
-          OneApm::Agent::Datastores.wrap("Redis", "pipelined", nil, callback) do
+          OneApm::Agent::Datastore.wrap("Redis", "pipelined", nil, callback) do
             call_pipelined_without_oneapm_trace commands, *rest
           end
         end
@@ -76,7 +76,7 @@ LibraryDetection.defer do
             end
           end
         end
-        OneApm::Agent::Datastores.notice_statement(args.inspect, elapsed)
+        OneApm::Agent::Datastore.notice_statement(args.inspect, elapsed)
       end
     end
   end

data/lib/one_apm/manager.rb

@@ -35,12 +35,12 @@ require 'one_apm/support/forked_process_channel'
 
 require 'one_apm/configuration'
 
-require 'one_apm/agent/sampler'
-require 'one_apm/agent/samplers/cpu_sampler'
-require 'one_apm/agent/samplers/memory_sampler'
-require 'one_apm/agent/samplers/object_sampler'
-require 'one_apm/agent/samplers/delayed_job_sampler'
-require 'one_apm/agent/samplers/vm_sampler'
+require 'one_apm/collector/sampler'
+require 'one_apm/collector/samplers/cpu_sampler'
+require 'one_apm/collector/samplers/memory_sampler'
+require 'one_apm/collector/samplers/object_sampler'
+require 'one_apm/collector/samplers/delayed_job_sampler'
+require 'one_apm/collector/samplers/vm_sampler'
 
 module OneApm
   module Manager
@@ -245,5 +245,37 @@ module OneApm
       require File.expand_path(path)
     end
 
+    def agent_should_start?
+        !blacklisted_constants? &&
+        !blacklisted_executables? &&
+        !in_blacklisted_rake_task?
+    end
+
+    def blacklisted_constants?
+      blacklisted?(OneApm::Manager.config[:'autostart.blacklisted_constants']) do |name|
+        OneApm::LanguageSupport.constant_is_defined?(name)
+      end
+    end
+
+    def blacklisted_executables?
+      blacklisted?(OneApm::Manager.config[:'autostart.blacklisted_executables']) do |bin|
+        File.basename($0) == bin
+      end
+    end
+
+    def blacklisted?(value, &block)
+      value.split(/\s*,\s*/).any?(&block)
+    end
+
+    def in_blacklisted_rake_task?
+      tasks = begin
+                ::Rake.application.top_level_tasks
+              rescue => e
+                OneApm::Manager.logger.debug("Not in Rake environment so skipping blacklisted_rake_tasks check: #{e}")
+                []
+              end
+      !(tasks & OneApm::Manager.config[:'autostart.blacklisted_rake_tasks'].split(/\s*,\s*/)).empty?
+    end
+
   end
 end

data/lib/one_apm/metrics/metric_spec.rb

@@ -1,8 +1,5 @@
 # encoding: utf-8
 
-# this struct uniquely defines a metric, optionally inside
-# the call scope of another metric
-# the call scope of another metric
 module OneApm
   class MetricSpec
     attr_reader   :name, :scope
@@ -79,4 +76,4 @@ module OneApm
       return (self.scope || '') <=> (o.scope || '')
     end
   end
-end
+end

data/lib/one_apm/probe/instrumentation.rb

@@ -6,14 +6,11 @@ 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
@@ -30,7 +27,6 @@ module OneApm
         LibraryDetection.detect!
       end
 
-      # require specified instrumentation
       def require_instrumentation file
         require file
       rescue => e
@@ -38,7 +34,6 @@ module OneApm
       end
 
       def install_shim
-        # Once we install instrumentation, you can't undo that by installing the shim.
         if @instrumented
           OneApm::Manager.logger.error "Cannot install the Agent shim after instrumentation has already been installed!"
           OneApm::Manager.logger.error caller.join("\n")
@@ -54,7 +49,9 @@ module OneApm
           @instrumentation_files << pattern
         end
       end
+
     end
+
     include Instrumentation
   end
 end

data/lib/one_apm/rack/developer_mode.rb

@@ -0,0 +1,221 @@
+# encoding: utf-8
+
+require 'rack'
+require 'rack/request'
+require 'rack/response'
+require 'rack/file'
+
+require 'one_apm/support/collection_helper'
+require 'one_apm/rack/middleware_base'
+require 'one_apm/rack/middleware_wrapper'
+
+require 'one_apm/transaction/transaction_sample'
+require 'one_apm/transaction/transaction_analysis'
+
+require 'one_apm/rack/developer_mode/helper'
+
+module OneApm
+  module Rack
+    class DeveloperMode < MiddlewareBase
+
+      VIEW_PATH = File.expand_path('../developer_mode/views/', __FILE__)
+
+      include OneApm::DeveloperModeHelper
+
+      def traced_call(env)
+        return @app.call(env) unless /^\/oneapm/ =~ ::Rack::Request.new(env).path_info
+        dup._call(env)
+      end
+
+      protected
+
+      def _call(env)
+        OneApm::Manager.ignore_transaction
+
+        @req = ::Rack::Request.new(env)
+        @rendered = false
+        case @req.path_info
+        when /assets/
+          ::Rack::File.new(VIEW_PATH).call(env)
+        when /index/
+          index
+        when /threads/
+          threads
+        when /reset/
+          reset
+        when /show_sample_summary/
+          show_sample_data
+        when /show_sample_detail/
+          show_sample_data
+        when /show_sample_sql/
+          show_sample_data
+        when /explain_sql/
+          explain_sql
+        when /^\/oneapm\/?$/
+          index
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def index
+        get_samples
+        render(:index)
+      end
+
+      def reset
+        OneApm::Manager.agent.transaction_sampler.reset!
+        OneApm::Manager.agent.sql_sampler.reset!
+        ::Rack::Response.new{|r| r.redirect('/oneapm/')}.finish
+      end
+
+      def explain_sql
+        get_segment
+
+        return render(:sample_not_found) unless @sample
+
+        @sql = @segment[:sql]
+        @trace = @segment[:backtrace]
+
+        if OneApm::Manager.agent.record_sql == :obfuscated
+          @obfuscated_sql = @segment.obfuscated_sql
+        end
+
+        _headers, explanations = @segment.explain_sql
+        if explanations
+          @explanation = explanations
+          if !@explanation.blank?
+            if @explanation.first.length < OneApm::MYSQL_EXPLAIN_COLUMNS.length
+              @row_headers = nil
+            else
+              @row_headers = OneApm::MYSQL_EXPLAIN_COLUMNS
+            end
+          end
+        end
+
+        render(:explain_sql)
+      end
+
+      def threads
+        render(:threads)
+      end
+
+      def render(view, layout=true)
+        add_rack_array = true
+        if view.is_a? Hash
+          layout = false
+          if view[:object]
+            # object *is* used here, as it is capture in the binding below
+            object = view[:object]
+          end
+
+          if view[:collection]
+            return view[:collection].map do |obj|
+              render({:partial => view[:partial], :object => obj})
+            end.join(' ')
+          end
+
+          if view[:partial]
+            add_rack_array = false
+            view = "_#{view[:partial]}"
+          end
+        end
+        binding = Proc.new {}.binding
+        if layout
+          body = render_with_layout(view) do
+            render_without_layout(view, binding)
+          end
+        else
+          body = render_without_layout(view, binding)
+        end
+        if add_rack_array
+          ::Rack::Response.new(body, 200, {'Content-Type' => 'text/html'}).finish
+        else
+          body
+        end
+      end
+
+      # You have to call this with a block - the contents returned from
+      # that block are interpolated into the layout
+      def render_with_layout(view)
+        body = ERB.new(File.read(File.join(VIEW_PATH, 'oneapm/layout.html.erb')))
+        body.result(Proc.new {}.binding)
+      end
+
+      # you have to pass a binding to this (a proc) so that ERB can have
+      # access to helper functions and local variables
+      def render_without_layout(view, binding)
+        ERB.new(File.read(File.join(VIEW_PATH, 'oneapm', view.to_s + '.html.erb')), nil, nil, 'frobnitz').result(binding)
+      end
+
+      def content_tag(tag, contents, opts={})
+        opt_values = opts.map {|k, v| "#{k}=\"#{v}\"" }.join(' ')
+        "<#{tag} #{opt_values}>#{contents}</#{tag}>"
+      end
+
+      def sample
+        @sample || @samples[0]
+      end
+
+      def params
+        @req.params
+      end
+
+      def segment
+        @segment
+      end
+
+      def show_sample_data
+        get_sample
+
+        return render(:sample_not_found) unless @sample
+
+        controller_metric = @sample.transaction_name
+
+        @sample_controller_name = controller_metric
+
+        @sql_segments = @sample.sql_segments
+        if params['d']
+          @sql_segments.sort!{|a,b| b.duration <=> a.duration }
+        end
+
+        sort_method = params['sort'] || :total_time
+        @profile_options = {:min_percent => 0.5, :sort_method => sort_method.to_sym}
+
+        render(:show_sample)
+      end
+
+      def get_samples
+        @samples = OneApm::Manager.agent.transaction_sampler.dev_mode_sample_buffer.samples.select do |sample|
+          sample.params[:path] != nil
+        end
+
+        return @samples = @samples.sort_by(&:duration).reverse                   if params['h']
+        return @samples = @samples.sort{|x,y| x.params[:uri] <=> y.params[:uri]} if params['u']
+        @samples = @samples.reverse
+      end
+
+      def get_sample
+        get_samples
+        id = params['id']
+        sample_id = id.to_i
+        @samples.each do |s|
+          if s.sample_id == sample_id
+            @sample = s
+            return
+          end
+        end
+      end
+
+      def get_segment
+        get_sample
+        return unless @sample
+
+        segment_id = params['segment'].to_i
+        @segment = @sample.find_segment(segment_id)
+      end
+    end
+  end
+end

data/lib/one_apm/rack/developer_mode/helper.rb

@@ -0,0 +1,299 @@
+# encoding: utf-8
+
+require 'pathname'
+require 'one_apm/support/collection_helper'
+
+module OneApm::DeveloperModeHelper
+  include OneApm::CollectionHelper
+
+  private
+
+  # limit of how many detail/SQL rows we display - very large data sets (~10000+) crash browsers
+  def trace_row_display_limit
+    2000
+  end
+
+  def trace_row_display_limit_reached
+   (!@detail_segment_count.nil? && @detail_segment_count > trace_row_display_limit) || @sample.sql_segments.length > trace_row_display_limit
+  end
+
+  # return the highest level in the call stack for the trace that is not rails or
+  # oneapm agent code
+  def application_caller(trace)
+    trace = strip_oa_from_backtrace(trace) unless params[:show_nr]
+    trace.each do |trace_line|
+      file, _line, gem = file_and_line(trace_line)
+      unless file && exclude_file_from_stack_trace?(file, false, gem)
+        return trace_line
+      end
+    end
+    trace.last
+  end
+
+  def application_stack_trace(trace, include_rails = false)
+    trace = strip_oa_from_backtrace(trace) unless params[:show_nr]
+    trace.reject do |trace_line|
+      file, _line, gem = file_and_line(trace_line)
+      file && exclude_file_from_stack_trace?(file, include_rails, gem)
+    end
+  end
+
+  def render_backtrace
+    if @segment[:backtrace]
+      content_tag('h3', '调用堆栈') +
+      render(:partial => 'stack_trace')
+    end
+  end
+
+  def h(text)
+    text
+  end
+
+  def agent_views_path(path)
+    path
+  end
+
+  # write the metric label for a segment metric in the detail view
+  def write_segment_label(segment)
+    link_to_function(segment.metric_name, "toggle_row_class($(this).closest('td').find('a')[0])")
+  end
+
+  # write the metric label for a segment metric in the summary table of metrics
+  def write_summary_segment_label(segment)
+    segment.metric_name
+  end
+
+  def write_stack_trace_line(trace_line)
+    trace_line
+  end
+
+  # print the formatted timestamp for a segment
+  def timestamp(segment)
+    sprintf("%1.3f", segment.entry_timestamp)
+  end
+
+  def format_timestamp(time)
+    time.strftime("%H:%M:%S")
+  end
+
+  def colorize(value, yellow_threshold = 0.05, red_threshold = 0.15, s=to_ms(value))
+    if value > yellow_threshold
+      color = (value > red_threshold ? 'red' : 'orange')
+      "<font color=#{color}>#{s}</font>"
+    else
+      "#{s}"
+    end
+  end
+
+  def expanded_image_path()
+    '/oneapm/assets/images/arrow-open.png'
+  end
+
+  def collapsed_image_path()
+    '/oneapm/assets/images/arrow-close.png'
+  end
+
+  def explain_sql_url(segment)
+    "explain_sql?id=#{@sample.sample_id}&amp;segment=#{segment.segment_id}"
+  end
+
+  def segment_duration_value(segment)
+    link_to colorize(segment.duration, 0.05, 0.15, "#{with_delimiter(to_ms(segment.duration))} ms"), explain_sql_url(segment)
+  end
+
+  def line_wrap_sql(sql)
+    sql.gsub(/\,/,', ').squeeze(' ') if sql
+  end
+
+  def render_sample_details(sample)
+    @indentation_depth=0
+    # skip past the root segments to the first child, which is always the controller
+    first_segment = sample.root_segment.called_segments.first
+
+    # render the segments, then the css classes to indent them
+    render_segment_details(first_segment).to_s + render_indentation_classes(@indentation_depth).to_s
+  end
+
+  def expand_segment_image(segment, depth)
+    if depth > 0
+      if !segment.called_segments.empty?
+        row_class =segment_child_row_class(segment)
+        link_to_function("<img src=\"#{collapsed_image_path}\" id=\"image_#{row_class}\" class_for_children=\"#{row_class}\" class=\"#{(!segment.called_segments.empty?) ? 'parent_segment_image' : 'child_segment_image'}\" />", "toggle_row_class(this)")
+      end
+    end
+  end
+
+  def segment_child_row_class(segment)
+    "segment#{segment.segment_id}"
+  end
+
+  def segment_row_classes(segment, depth)
+    classes = []
+
+    classes << "segment#{segment.parent_segment.segment_id}" if depth > 1
+
+    classes << "view_segment" if segment.metric_name.index('View') == 0
+    classes << "summary_segment" if segment.is_a?(OneApm::TransactionSample::CompositeSegment)
+
+    classes.join(' ')
+  end
+
+  # render_segment_details should be called before calling this method
+  def render_indentation_classes(depth)
+    styles = []
+     (1..depth).each do |d|
+      styles <<  ".segment_indent_level#{d} { display: inline-block; margin-left: #{(d-1)*10}px }"
+    end
+    content_tag("style", styles.join(' '))
+  end
+
+  def explain_sql_link(segment, child_sql = false)
+    link_to 'SQL', explain_sql_url(segment)
+  end
+
+  def explain_sql_links(segment)
+    if segment[:sql]
+      explain_sql_link segment
+    else
+      links = []
+      segment.called_segments.each do |child|
+        if child[:sql]
+          links << explain_sql_link(child, true)
+        end
+      end
+      links[0..1].join(', ') + (links.length > 2?', ...':'')
+    end
+  end
+
+  private
+  # return three objects, the file path, the line in the file, and the gem the file belongs to
+  # if found
+  def file_and_line(stack_trace_line)
+    if stack_trace_line =~ /^(?:(\w+) \([\d.]*\) )?(.*):(\d+)/
+      return $2, $3, $1
+    else
+      return nil
+    end
+  end
+
+  def render_segment_details(segment, depth=0)
+    @detail_segment_count ||= 0
+    @detail_segment_count += 1
+
+    return '' if @detail_segment_count > trace_row_display_limit
+
+    @indentation_depth = depth if depth > @indentation_depth
+    repeat = nil
+    if segment.is_a?(OneApm::TransactionSample::CompositeSegment)
+      html = ''
+    else
+      repeat = segment.parent_segment.detail_segments.length if segment.parent_segment.is_a?(OneApm::TransactionSample::CompositeSegment)
+      html = render(:partial => 'segment', :object => [segment, depth, repeat])
+      depth += 1
+    end
+
+    segment.called_segments.each do |child|
+      html << render_segment_details(child, depth)
+    end
+
+    html
+  end
+
+  def exclude_file_from_stack_trace?(file, include_rails, gem=nil)
+    return false if include_rails
+    return true if file !~ /\.(rb|java)/
+    return true if %w[rack activerecord activeresource activesupport actionpack railties].include? gem
+    %w[/actionmailer/
+             /activerecord
+             /activeresource
+             /activesupport
+             /lib/mongrel
+             /actionpack
+             /passenger/
+             /railties
+             benchmark.rb].each { |s| return true if file.include? s }
+     false
+  end
+
+  def link_to(name, location)
+    location = "/oneapm/#{location}" unless /:\/\// =~ location
+    "<a href=\"#{location}\">#{name}</a>"
+  end
+
+  def link_to_if(predicate, text, location="")
+    if predicate
+      link_to(text, location)
+    else
+      text
+    end
+  end
+
+  def link_to_unless_current(text, hash)
+    unless params[hash.keys[0].to_s]
+      link_to(text,"?#{hash.keys[0]}=#{hash.values[0]}")
+    else
+      text
+    end
+  end
+
+  def cycle(even, odd)
+    @cycle ||= 'a'
+    if @cycle == 'a'
+      @cycle = 'b'
+      even
+    else
+      @cycle = 'a'
+      odd
+    end
+  end
+
+  def link_to_function(title, javascript)
+    "<a href=\"#\" onclick=\"#{javascript}; return false;\">#{title}</a>"
+  end
+
+  def mime_type_from_extension(extension)
+    extension = extension[/[^.]*$/].dncase
+    case extension
+      when 'png'; 'image/png'
+      when 'gif'; 'image/gif'
+      when 'jpg'; 'image/jpg'
+      when 'css'; 'text/css'
+      when 'js'; 'text/javascript'
+    else 'text/plain'
+    end
+  end
+  def to_ms(number)
+   (number*1000).round
+  end
+  def to_percentage(value)
+   (value * 100).round if value
+  end
+  def with_delimiter(val)
+    return '0' if val.nil?
+    parts = val.to_s.split('.')
+    parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1,")
+    parts.join '.'
+  end
+
+  SORT_REPLACEMENTS = {
+      "Total" => :total_time,
+      "Self" => :self_time,
+      "Child" => :children_time,
+      "Wait" => :wait_time
+  }
+
+  def profile_table(sample, options)
+    out = StringIO.new
+    printer = RubyProf::GraphHtmlPrinter.new(sample.profile)
+    printer.print(out, options)
+    out = out.string[/<body>(.*)<\/body>/im, 0].gsub('<table>', '<table class=profile>')
+    SORT_REPLACEMENTS.each do |text, param|
+      replacement = (options[:sort_method] == param) ?
+          "<th> #{text}&nbsp;&darr;</th>" :
+          "<th>#{link_to text, "show_sample_summary?id=#{sample.sample_id}&sort=#{param}"}</th>"
+
+      out.gsub!(/<th> +#{text}<\/th>/, replacement)
+    end
+    out
+  end
+end