newrelic_rpm 2.13.4 → 2.13.5.beta1

data/lib/new_relic/control.rb

@@ -1,5 +1,7 @@
 require 'yaml'
+require 'conditional_vendored_metric_parser'
 require 'new_relic/local_environment'
+
 require 'singleton'
 require 'erb'
 require 'socket'
@@ -11,6 +13,9 @@ require 'new_relic/control/configuration'
 require 'new_relic/control/server_methods'
 require 'new_relic/control/instrumentation'
 
+require 'new_relic/agent'
+require 'new_relic/delayed_job_injection'
+
 module NewRelic
 
   # The Control is a singleton responsible for the startup and
@@ -42,21 +47,19 @@ module NewRelic
       def instance
         @instance ||= new_instance
       end
+      
+      def mark_browser_request
+        Thread::current[:browser_request] = true
+      end
+      
 
       # Create the concrete class for environment specific behavior:
       def new_instance
         @local_env = NewRelic::LocalEnvironment.new
         if @local_env.framework == :test
-          # You can set this env var if you want to run the tests
-          # without Rails.
           config = File.expand_path("../../../test/config/newrelic.yml", __FILE__)
-          if ENV['SKIP_RAILS']
-            require "new_relic/control/frameworks/ruby.rb"
-            NewRelic::Control::Frameworks::Ruby.new @local_env, config
-          else
-            require "config/test_control"
-            NewRelic::Control::Frameworks::Test.new @local_env, config
-          end
+          require "config/test_control"
+          NewRelic::Control::Frameworks::Test.new @local_env, config
         else
           begin
             require "new_relic/control/frameworks/#{@local_env.framework}.rb"
@@ -93,16 +96,8 @@ module NewRelic
     # is called one or more times.
     #
     def init_plugin(options={})
-      require 'conditional_vendored_metric_parser'
-      
       options['app_name'] = ENV['NEWRELIC_APP_NAME'] if ENV['NEWRELIC_APP_NAME']
 
-      require 'new_relic/agent'
-
-      # Load the DJ injection now.  If you do it sooner, DJ might not be loaded and
-      # you'll miss it.
-      require 'new_relic/delayed_job_injection'
-
       # Merge the stringified options into the config as overrides:
       logger_override = options.delete(:log)
       environment_name = options.delete(:env) and self.env = environment_name

data/lib/new_relic/control/configuration.rb

@@ -63,6 +63,7 @@ module NewRelic
         # Always initialized with a default
         fetch('apdex_t').to_f
       end
+      
       def license_key
         fetch('license_key')
       end

data/lib/new_relic/control/frameworks/rails.rb

@@ -1,7 +1,8 @@
 # Control subclass instantiated when Rails is detected.  Contains
 # Rails specific configuration, instrumentation, environment values,
 # etc.
-class NewRelic::Control::Frameworks::Rails < NewRelic::Control
+require 'new_relic/control/frameworks/ruby'
+class NewRelic::Control::Frameworks::Rails < NewRelic::Control::Frameworks::Ruby
 
   def env
     @env ||= RAILS_ENV.dup
@@ -120,11 +121,13 @@ class NewRelic::Control::Frameworks::Rails < NewRelic::Control
       end
     end
   end
-
+  
   def install_shim
     super
     require 'new_relic/agent/instrumentation/controller_instrumentation'
-    ActionController::Base.send :include, NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
+    ::ActionController::Base.class_eval {
+      include NewRelic::Agent::Instrumentation::ControllerInstrumentation::Shim
+    }
   end
-
 end
+

data/lib/new_relic/control/frameworks/rails3.rb

@@ -9,7 +9,7 @@ class NewRelic::Control::Frameworks::Rails3 < NewRelic::Control::Frameworks::Rai
   end
 
   def root
-    @root ||= Rails.root.to_s
+    @root ||= ::Rails.root.to_s
   end
 
   def logger

data/lib/new_relic/control/instrumentation.rb

@@ -32,25 +32,9 @@ module NewRelic
           @instrumentation_files << pattern
         end
       end
-
-      def _delayed_instrumentation
-        Rails.configuration.after_initialize do
-          _install_instrumentation
-        end
-      rescue
-        _install_instrumentation
-      end
-
+      
       def install_instrumentation
-        if defined?(Rails) && !Rails.initialized?
-          _delayed_instrumentation
-        else
-          _install_instrumentation
-        end
-      rescue NameError
-        # needed in the rails 3 case, where Rails.initialized? raises
-        # an error if rails has not been initialised. which is totally sane.
-        _delayed_instrumentation
+        _install_instrumentation
       end
 
       def load_samplers

data/lib/new_relic/local_environment.rb

@@ -42,7 +42,7 @@ module NewRelic
     # settings.  Must pass either a value or a block.  Block
     # is called to get the value and any raised errors are
     # silently ignored.
-    def append_environment_value name, value = nil
+    def append_environment_value(name, value = nil)
       value = yield if block_given?
       @config[name] = value if value
     rescue Exception
@@ -73,35 +73,49 @@ module NewRelic
       @dispatcher_instance_id
     end
 
-    # Collect base statistics about the environment and record them for
-    # comparison and change detection.
-    def gather_environment_info
-      append_environment_value 'Framework', @framework.to_s
-      append_environment_value 'Dispatcher', @dispatcher.to_s if @dispatcher
-      append_environment_value 'Dispatcher instance id', @dispatcher_instance_id if @dispatcher_instance_id
-      # This just creates a lot of keys
-      # append_environment_value('Application root') { File.expand_path(NewRelic::Control.instance.root) }
+    def gather_ruby_info
       append_environment_value('Ruby version'){ RUBY_VERSION }
       append_environment_value('Ruby description'){ RUBY_DESCRIPTION } if defined? ::RUBY_DESCRIPTION
       append_environment_value('Ruby platform') { RUBY_PLATFORM }
       append_environment_value('Ruby patchlevel') { RUBY_PATCHLEVEL }
+      # room here for other ruby implementations, when.
       if defined? ::JRUBY_VERSION
-        append_environment_value('JRuby version') { JRUBY_VERSION }
-        append_environment_value('Java VM version') { ENV_JAVA['java.vm.version']}
+        gather_jruby_info
       end
-      append_environment_value('OS version') { `uname -v` }
-      append_environment_value('OS') { `uname -s` } ||
-      append_environment_value('OS') { ENV['OS'] }
-      append_environment_value('Arch') { `uname -p` } ||
-      append_environment_value('Arch') { ENV['PROCESSOR_ARCHITECTURE'] }
-      # See what the number of cpus is, works only on linux.
+    end
+    
+    def gather_jruby_info
+      append_environment_value('JRuby version') { JRUBY_VERSION }
+      append_environment_value('Java VM version') { ENV_JAVA['java.vm.version']}
+    end
+    
+    # See what the number of cpus is, works only on linux.    
+    def gather_cpu_info
+      return unless File.readable? '/proc/cpuinfo'
       @processors = append_environment_value('Processors') do
         processors = File.readlines('/proc/cpuinfo').select { |line| line =~ /^processor\s*:/ }.size
         raise "Cannot determine the number of processors in /proc/cpuinfo" unless processors > 0
         processors
-      end if File.readable? '/proc/cpuinfo'
-      # The current Rails environment (development, test, or production).
-      append_environment_value('Environment') { NewRelic::Control.instance.env }
+      end
+    end
+
+    def gather_architecture_info
+      append_environment_value('Arch') { `uname -p` } ||
+        append_environment_value('Arch') { ENV['PROCESSOR_ARCHITECTURE'] }
+    end
+
+    def gather_os_info
+      append_environment_value('OS version') { `uname -v` }
+      append_environment_value('OS') { `uname -s` } ||
+        append_environment_value('OS') { ENV['OS'] }
+    end
+    
+    def gather_system_info
+      gather_architecture_info
+      gather_cpu_info
+    end
+
+    def gather_revision_info
       # Look for a capistrano file indicating the current revision:
       rev_file = File.join(NewRelic::Control.instance.root, "REVISION")
       if File.readable?(rev_file) && File.size(rev_file) < 64
@@ -109,22 +123,56 @@ module NewRelic
           File.open(rev_file) { | file | file.readline.strip }
         end
       end
-      # The name of the database adapter for the current environment.
-      if defined? ::ActiveRecord
-        append_environment_value 'Database adapter' do
-          ActiveRecord::Base.configurations[RAILS_ENV]['adapter']
-        end
-        append_environment_value 'Database schema version' do
-          ActiveRecord::Migrator.current_version
+    end
+
+    def gather_ar_adapter_info
+      # The name of the database adapter for the current environment.      
+      append_environment_value 'Database adapter' do
+        if defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
+            ActiveRecord::Base.respond_to?(:configurations)
+          config = ActiveRecord::Base.configurations[NewRelic::Control.instance.env]
+          if config
+            config['adapter']
+          end
         end
       end
+      append_environment_value 'Database schema version' do
+        ActiveRecord::Migrator.current_version
+      end
+    end
+
+    def gather_dm_adapter_info
+      append_environment_value 'DataMapper version' do
+        require 'dm-core/version'
+        DataMapper::VERSION
+      end
+    end
+
+    def gather_db_info
+      # room here for more database adapters, when.
+      if defined? ::ActiveRecord
+        gather_ar_adapter_info
+      end
       if defined? ::DataMapper
-        append_environment_value 'DataMapper version' do
-          require 'dm-core/version'
-          DataMapper::VERSION
-        end
+        gather_dm_adapter_info
       end
     end
+
+    # Collect base statistics about the environment and record them for
+    # comparison and change detection.
+    def gather_environment_info
+      append_environment_value 'Framework', @framework.to_s
+      append_environment_value 'Dispatcher', @dispatcher.to_s if @dispatcher
+      append_environment_value 'Dispatcher instance id', @dispatcher_instance_id if @dispatcher_instance_id
+      append_environment_value('Environment') { NewRelic::Control.instance.env }
+      
+      # miscellaneous other helpful debugging information
+      gather_ruby_info
+      gather_system_info
+      gather_revision_info
+      gather_db_info
+    end
+    
     # Take a snapshot of the environment information for this application
     # Returns an associative array
     def snapshot
@@ -134,30 +182,32 @@ module NewRelic
       i
     end
 
+    def working_juby?
+      !(defined?(::JRuby) && Jruby.respond_to?(:runtime) && !JRuby.runtime.is_object_space_enabled)
+    end
+
+    def find_class_in_object_space(klass)
+      ObjectSpace.each_object(klass) do |x|
+        return x
+      end
+    end
+
     def mongrel
-      # Note that the odd defined? sequence is necessary to work around a bug in an older version
-      # of JRuby.
-      return @mongrel if @mongrel || ! (defined?(::Mongrel) && defined?(::Mongrel::HttpServer))
-      ObjectSpace.each_object(Mongrel::HttpServer) do |mongrel|
-        @mongrel = mongrel
-      end unless defined?(::JRuby) && !JRuby.runtime.is_object_space_enabled
+      return @mongrel if @mongrel
+      if defined?(::Mongrel) && defined?(::Mongrel::HttpServer) && working_jruby?
+        @mongrel = find_class_in_object_space(::Mongrel::HttpServer)
+      end
       @mongrel
     end
 
     def unicorn
-      return @unicorn if @unicorn || ! (defined?(::Unicorn) && defined?(::Unicorn::HttpServer))
-      ObjectSpace.each_object(Unicorn::HttpServer) do |unicorn|
-        @unicorn = unicorn
-      end unless defined?(::JRuby) && !JRuby.runtime.is_object_space_enabled
+      return @unicorn if @unicorn
+      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && working_jruby?
+        @unicorn = find_class_in_object_space(::Unicorn::HttpServer)
+      end
       @unicorn
     end
 
-    # Obsolete method for DelayedJob instrumentation support.  Now all DJ instrumentation
-    # is bundled in the newrelic_rpm gem and nobody should be invoking this method.
-    def delayed_worker=(worker)
-      $stderr.puts "WARNING: obsolete call to delayed_worker=(worker).  Please remove custom DJ instrumentation."
-    end
-
     private
 
     # Although you can override the framework with NEWRELIC_DISPATCHER this
@@ -177,14 +227,14 @@ module NewRelic
       # Note that the odd defined? sequence is necessary to work around a bug in an older version
       # of JRuby.
       @framework ||= case
-        when ENV['NEWRELIC_FRAMEWORK'] then ENV['NEWRELIC_FRAMEWORK'].to_sym
-        when defined?(::NewRelic::TEST) then :test
-        when defined?(::Merb) && defined?(::Merb::Plugins) then :merb
-        when defined?(::Rails) then check_rails_version
-        when defined?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra
-        when defined?(::NewRelic::IA) then :external
-      else :ruby
-      end
+                     when ENV['NEWRELIC_FRAMEWORK'] then ENV['NEWRELIC_FRAMEWORK'].to_sym
+                     when defined?(::NewRelic::TEST) then :test
+                     when defined?(::Merb) && defined?(::Merb::Plugins) then :merb
+                     when defined?(::Rails) then check_rails_version
+                     when defined?(::Sinatra) && defined?(::Sinatra::Base) then :sinatra
+                     when defined?(::NewRelic::IA) then :external
+                     else :ruby
+                     end
     end
 
     def check_rails_version
@@ -197,7 +247,7 @@ module NewRelic
 
     def check_for_torquebox
       return unless defined?(::JRuby) &&
-         ( Java::OrgTorqueboxRailsWebDeployers::RailsRackDeployer rescue nil)
+        ( Java::OrgTorqueboxRailsWebDeployers::RailsRackDeployer rescue nil)
       @dispatcher = :torquebox
     end
 
@@ -205,12 +255,20 @@ module NewRelic
       return unless defined?(::JRuby) &&
         (((com.sun.grizzly.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
           defined?(com::sun::grizzly::jruby::rack::DefaultRackApplicationFactory)) ||
-         ((org.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
-          defined?(org::jruby::rack::DefaultRackApplicationFactory)) ||
-         defined?(::GlassFish::Server))
+         (jruby_rack? && defined?(::GlassFish::Server)))
       @dispatcher = :glassfish
     end
 
+    def check_for_trinidad
+      return unless defined?(::JRuby) && jruby_rack? && defined?(::Trinidad::Server)
+      @dispatcher = :trinidad
+    end
+
+    def jruby_rack?
+      ((org.jruby.rack.DefaultRackApplicationFactory rescue nil) &&
+       defined?(org::jruby::rack::DefaultRackApplicationFactory))
+    end
+
     def check_for_webrick
       return unless defined?(::WEBrick) && defined?(::WEBrick::VERSION)
       @dispatcher = :webrick

data/lib/new_relic/rack/developer_mode.rb

@@ -2,256 +2,261 @@ 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::Rack
-class DeveloperMode
+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')
+      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
+      include NewRelic::DeveloperModeHelper
 
-  def call(env)
-    return @app.call(env) unless /^\/newrelic/ =~ Rack::Request.new(env).path_info
-    dup._call(env)
-  end
+      def initialize(app)
+        @app = app
+      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
+      def call(env)
+        return @app.call(env) unless /^\/newrelic/ =~ Rack::Request.new(env).path_info
+        dup._call(env)
+      end
 
-  private
+      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
 
-  def index
-    get_samples
-    render(:index)
-  end
+      private
 
-  def reset
-    NewRelic::Agent.instance.transaction_sampler.reset!
-    Rack::Response.new{|r| r.redirect('/newrelic/')}.finish
-  end
+      def index
+        get_samples
+        render(:index)
+      end
 
-  def explain_sql
-    get_segment
+      def reset
+        NewRelic::Agent.instance.transaction_sampler.reset!
+        Rack::Response.new{|r| r.redirect('/newrelic/')}.finish
+      end
 
-    return render(:sample_not_found) unless @sample
+      def explain_sql
+        get_segment
 
-    @sql = @segment[:sql]
-    @trace = @segment[:backtrace]
+        return render(:sample_not_found) unless @sample
 
-    if NewRelic::Agent.agent.record_sql == :obfuscated
-      @obfuscated_sql = @segment.obfuscated_sql
-    end
+        @sql = @segment[:sql]
+        @trace = @segment[:backtrace]
 
-    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
+        if NewRelic::Agent.agent.record_sql == :obfuscated
+          @obfuscated_sql = @segment.obfuscated_sql
         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]
+        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
 
-      if view[:collection]
-        return view[:collection].map do |object|
-          render({:partial => view[:partial], :object => object})
-        end.join(' ')
+      def profile
+        NewRelic::Control.instance.profiling = params['start'] == 'true'
+        index
       end
 
-      if view[:partial]
-        add_rack_array = false
-        view = "_#{view[:partial]}"
+      def threads
+        render(:threads)
       end
-    end
-    binding = Proc.new {}.binding
-    if layout
-      body = render_with_layout(view) do
-        render_without_layout(view, binding)
+
+      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
-    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 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
+      # 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 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 sample
+        @sample || @samples[0]
+      end
 
-  def params
-    @req.params
-  end
+      def params
+        @req.params
+      end
 
-  def segment
-    @segment
-  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
+      # 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
+        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
-    end
-    render(:show_source)
-  end
 
-  def show_sample_data
-    get_sample
+      def show_sample_data
+        get_sample
 
-    return render(:sample_not_found) unless @sample
+        return render(:sample_not_found) unless @sample
 
-    @request_params = @sample.params['request_params'] || {}
-    @custom_params = @sample.params['custom_params'] || {}
+        @request_params = @sample.params['request_params'] || {}
+        @custom_params = @sample.params['custom_params'] || {}
 
-    controller_metric = @sample.root_segment.called_segments.first.metric_name
+        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
+        metric_parser = NewRelic::MetricParser::MetricParser.for_metric_named controller_metric
+        @sample_controller_name = metric_parser.controller_name
+        @sample_action_name = metric_parser.action_name
 
-    render(:show_sample)
-  end
+        render(:show_sample)
+      end
 
-    def get_samples
-    @samples = NewRelic::Agent.instance.transaction_sampler.samples.select do |sample|
-      sample.params[:path] != nil
-    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
+        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
+      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
-    end
-  end
 
-  def get_segment
-    get_sample
-    return unless @sample
+      def get_segment
+        get_sample
+        return unless @sample
 
-    segment_id = params['segment'].to_i
-    @segment = @sample.find_segment(segment_id)
+        segment_id = params['segment'].to_i
+        @segment = @sample.find_segment(segment_id)
+      end
+    end
   end
 end
-end