dolores_rpm 3.2.0.2

data/lib/new_relic/rack/developer_mode.rb

@@ -0,0 +1,268 @@
+require 'rack'
+require 'rack/request'
+require 'rack/response'
+require 'rack/file'
+require 'new_relic/metric_parser/metric_parser'
+require 'new_relic/collection_helper'
+
+module NewRelic
+  module Rack
+    class DeveloperMode
+
+      VIEW_PATH = File.expand_path('../../../../ui/views/', __FILE__)
+      HELPER_PATH = File.expand_path('../../../../ui/helpers/', __FILE__)
+      require File.join(HELPER_PATH, 'developer_mode_helper.rb')
+
+
+      include NewRelic::DeveloperModeHelper
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        return @app.call(env) unless /^\/newrelic/ =~ ::Rack::Request.new(env).path_info
+        dup._call(env)
+      end
+
+      protected
+
+      def _call(env)
+        @req = ::Rack::Request.new(env)
+        @rendered = false
+        case @req.path_info
+        when /profile/
+          profile
+        when /file/
+          ::Rack::File.new(VIEW_PATH).call(env)
+        when /index/
+          index
+        when /threads/
+          threads
+        when /reset/
+          reset
+        when /show_sample_detail/
+          show_sample_data
+        when /show_sample_summary/
+          show_sample_data
+        when /show_sample_sql/
+          show_sample_data
+        when /explain_sql/
+          explain_sql
+        when /show_source/
+          show_source
+        when /^\/newrelic\/?$/
+          index
+        else
+          @app.call(env)
+        end
+      end
+
+      private
+
+      def index
+        get_samples
+        render(:index)
+      end
+
+      def reset
+        NewRelic::Agent.instance.transaction_sampler.reset!
+        NewRelic::Agent.instance.sql_sampler.reset!
+        ::Rack::Response.new{|r| r.redirect('/newrelic/')}.finish
+      end
+
+      def explain_sql
+        get_segment
+
+        return render(:sample_not_found) unless @sample
+
+        @sql = @segment[:sql]
+        @trace = @segment[:backtrace]
+
+        if NewRelic::Agent.agent.record_sql == :obfuscated
+          @obfuscated_sql = @segment.obfuscated_sql
+        end
+
+        explanations = @segment.explain_sql
+        if explanations
+          @explanation = explanations.first
+          if !@explanation.blank?
+            first_row = @explanation.first
+            # Show the standard headers if it looks like a mysql explain plan
+            # Otherwise show blank headers
+            if first_row.length < NewRelic::MYSQL_EXPLAIN_COLUMNS.length
+              @row_headers = nil
+            else
+              @row_headers = NewRelic::MYSQL_EXPLAIN_COLUMNS
+            end
+          end
+        end
+        render(:explain_sql)
+      end
+
+      def profile
+        NewRelic::Control.instance.profiling = params['start'] == 'true'
+        index
+      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 = view[:object]
+          end
+
+          if view[:collection]
+            return view[:collection].map do |object|
+              render({:partial => view[:partial], :object => object})
+            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).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, 'layouts/newrelic_default.rhtml')))
+        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, 'newrelic', view.to_s + '.rhtml')), 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
+
+
+      # show the selected source file with the highlighted selected line
+      def show_source
+        @filename = params['file']
+        line_number = params['line'].to_i
+
+        if !File.readable?(@filename)
+          @source="<p>Unable to read #{@filename}.</p>"
+          return
+        end
+        begin
+          file = File.new(@filename, 'r')
+        rescue => e
+          @source="<p>Unable to access the source file #{@filename} (#{e.message}).</p>"
+          return
+        end
+        @source = ""
+
+        @source << "<pre>"
+        file.each_line do |line|
+          # place an anchor 6 lines above the selected line (if the line # < 6)
+          if file.lineno == line_number - 6
+            @source << "</pre><pre id = 'selected_line'>"
+            @source << line.rstrip
+            @source << "</pre><pre>"
+
+            # highlight the selected line
+          elsif file.lineno == line_number
+            @source << "</pre><pre class = 'selected_source_line'>"
+            @source << line.rstrip
+            @source << "</pre><pre>"
+          else
+            @source << line
+          end
+        end
+        render(:show_source)
+      end
+
+      def show_sample_data
+        get_sample
+
+        return render(:sample_not_found) unless @sample
+
+        @request_params = @sample.params['request_params'] || {}
+        @custom_params = @sample.params['custom_params'] || {}
+
+        controller_metric = @sample.root_segment.called_segments.first.metric_name
+
+        metric_parser = NewRelic::MetricParser::MetricParser.for_metric_named controller_metric
+        @sample_controller_name = metric_parser.controller_name
+        @sample_action_name = metric_parser.action_name
+
+        @sql_segments = @sample.sql_segments
+        if params['d']
+          @sql_segments.sort!{|a,b| b.duration <=> a.duration }
+        end
+        
+        render(:show_sample)
+      end
+
+      def get_samples
+        @samples = NewRelic::Agent.instance.transaction_sampler.samples.select do |sample|
+          sample.params[:path] != nil
+        end
+
+        return @samples = @samples.sort{|x,y| y.omit_segments_with('(Rails/Application Code Loading)|(Database/.*/.+ Columns)').duration <=>
+          x.omit_segments_with('(Rails/Application Code Loading)|(Database/.*/.+ Columns)').duration} 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 = stripped_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/new_relic/recipes.rb

@@ -0,0 +1,73 @@
+# When installed as a plugin this is loaded automatically.
+#
+# When installed as a gem, you need to add
+#  require 'new_relic/recipes'
+# to your deploy.rb
+#
+# Defined deploy:notify_rpm which will send information about the deploy to New Relic.
+# The task will run on app servers except where no_release is true.
+# If it fails, it will not affect the task execution or do a rollback.
+#
+make_notify_task = Proc.new do
+
+  namespace :newrelic do
+
+    # on all deployments, notify New Relic
+    desc "Record a deployment in New Relic (newrelic.com)"
+    task :notice_deployment, :roles => :app, :except => {:no_release => true } do
+      rails_env = fetch(:newrelic_rails_env, fetch(:rails_env, "production"))
+      require File.join(File.dirname(__FILE__), 'command.rb')
+      begin
+        # allow overrides to be defined for revision, description, changelog and appname
+        rev = fetch(:newrelic_revision) if exists?(:newrelic_revision)
+        description = fetch(:newrelic_desc) if exists?(:newrelic_desc)
+        changelog = fetch(:newrelic_changelog) if exists?(:newrelic_changelog)
+        appname = fetch(:newrelic_appname) if exists?(:newrelic_appname)
+        if !changelog
+          logger.debug "Getting log of changes for New Relic Deployment details"
+          from_revision = source.next_revision(current_revision)
+          if scm == :git
+            log_command = "git log --no-color --pretty=format:'  * %an: %s' --abbrev-commit --no-merges #{previous_revision}..#{real_revision}"
+          else
+            log_command = "#{source.log(from_revision)}"
+          end
+          changelog = `#{log_command}`
+        end
+        new_revision = rev || source.query_revision(source.head()) do |cmd|
+          logger.debug "executing locally: '#{cmd}'"
+          `#{cmd}`
+        end
+        deploy_options = { :environment => rails_env,
+          :revision => new_revision,
+          :changelog => changelog,
+          :description => description,
+          :appname => appname }
+        logger.debug "Uploading deployment to New Relic"
+        deployment = NewRelic::Command::Deployments.new deploy_options
+        deployment.run
+        logger.info "Uploaded deployment information to New Relic"
+      rescue NewRelic::Command::CommandFailure => e
+        logger.info e.message
+      rescue Capistrano::CommandError
+        logger.info "Unable to notify New Relic of the deployment... skipping"
+      rescue Exception => e
+        logger.info "Error creating New Relic deployment (#{e})\n#{e.backtrace.join("\n")}"
+      end
+      # WIP: For rollbacks, let's update the deployment we created with an indication of the failure:
+      # on_rollback do
+      #   run(...)
+      # end
+    end
+  end
+end
+require 'capistrano/version'
+if defined?(Capistrano::Version::MAJOR) && Capistrano::Version::MAJOR < 2
+  STDERR.puts "Unable to load #{__FILE__}\nNew Relic Capistrano hooks require at least version 2.0.0"
+else
+  instance = Capistrano::Configuration.instance
+  if instance
+    instance.load &make_notify_task
+  else
+    make_notify_task.call
+  end
+end