newrelic_rpm 3.12.0.288 → 9.10.2

data/lib/new_relic/rack/developer_mode.rb

@@ -1,321 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-require 'rack/request'
-require 'rack/response'
-require 'rack/file'
-
-require 'conditional_vendored_metric_parser'
-require 'new_relic/collection_helper'
-require 'new_relic/metric_parser/metric_parser'
-require 'new_relic/rack/agent_middleware'
-require 'new_relic/agent/instrumentation/middleware_proxy'
-
-module NewRelic
-  module Rack
-    # This middleware provides the 'developer mode' feature of newrelic_rpm,
-    # which allows you to see data about local web transactions in development
-    # mode immediately without needing to send this data to New Relic's servers.
-    #
-    # Enabling developer mode has serious performance and security impact, and
-    # thus you should never use this middleware in a production or non-local
-    # environment.
-    #
-    # This middleware should be automatically inserted in most contexts, but if
-    # automatic middleware insertion fails, you may manually insert it into your
-    # middleware chain.
-    #
-    # @api public
-    #
-    class DeveloperMode < AgentMiddleware
-
-      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')
-      require 'new_relic/rack/developer_mode/segment_summary'
-
-      include NewRelic::DeveloperModeHelper
-
-      class << self
-        attr_writer :profiling_enabled
-      end
-
-      def self.profiling_enabled?
-        @profiling_enabled
-      end
-
-      def traced_call(env)
-        return @app.call(env) unless /^\/newrelic/ =~ ::Rack::Request.new(env).path_info
-        dup._call(env)
-      end
-
-      protected
-
-      def _call(env)
-        NewRelic::Agent.ignore_transaction
-
-        @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 /^\/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
-
-        _headers, explanations = @segment.explain_sql
-        if explanations
-          @explanation = explanations
-          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
-        should_be_on = (params['start'] == 'true')
-        NewRelic::Rack::DeveloperMode.profiling_enabled = should_be_on
-
-        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 *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, '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
-
-      def show_sample_data
-        get_sample
-
-        return render(:sample_not_found) unless @sample
-
-        @request_params = request_attributes_for(@sample)
-        @custom_params = custom_attributes_for(@sample)
-
-        controller_metric = @sample.transaction_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 = sql_segments(@sample)
-        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 = NewRelic::Agent.instance.transaction_sampler.dev_mode_sample_buffer.samples.select do |sample|
-          sample.transaction_name != 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.root_node.find_node(segment_id)
-      end
-
-      def custom_attributes_for(sample)
-        sample.attributes.custom_attributes_for(NewRelic::Agent::AttributeFilter::DST_DEVELOPER_MODE)
-      end
-
-      REQUEST_PARAMETERS_PREFIX = "request.parameters".freeze
-
-      def request_attributes_for(sample)
-        agent_attributes = sample.attributes.agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_DEVELOPER_MODE)
-        agent_attributes.inject({}) do |memo, (key, value)|
-          memo[key] = value if key.to_s.start_with?(REQUEST_PARAMETERS_PREFIX)
-          memo
-        end
-      end
-
-      def breakdown_data(sample, limit = nil)
-        metric_hash = {}
-        sample.each_node_with_nest_tracking do |node|
-          unless node == sample.root_node
-            metric_name = node.metric_name
-            metric_hash[metric_name] ||= SegmentSummary.new(metric_name, sample)
-            metric_hash[metric_name] << node
-            metric_hash[metric_name]
-          end
-        end
-
-        data = metric_hash.values
-
-        data.sort! do |x,y|
-          y.exclusive_time <=> x.exclusive_time
-        end
-
-        if limit && data.length > limit
-          data = data[0..limit - 1]
-        end
-
-        # add one last node for the remaining time if any
-        remainder = sample.duration
-        data.each do |node|
-          remainder -= node.exclusive_time
-        end
-
-        if (remainder*1000).round > 0
-          remainder_summary = SegmentSummary.new('Remainder', sample)
-          remainder_summary.total_time = remainder_summary.exclusive_time = remainder
-          remainder_summary.call_count = 1
-          data << remainder_summary
-        end
-
-        data
-      end
-
-      # return an array of sql statements executed by this transaction
-      # each element in the array contains [sql, parent_segment_metric_name, duration]
-      def sql_segments(sample, show_non_sql_segments = true)
-        segments = []
-        sample.each_node do |segment|
-          segments << segment if segment[:sql] || segment[:sql_obfuscated] || (show_non_sql_segments && segment[:key])
-        end
-        segments
-      end
-
-    end
-  end
-end

data/lib/new_relic/rack/error_collector.rb

@@ -1,27 +0,0 @@
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'new_relic/rack/agent_middleware'
-
-module NewRelic::Rack
-  # This middleware is no longer used by the agent by default, but remains here
-  # for API compatibility purposes.
-  #
-  # You should remove any references to it from your config.ru or other rack
-  # middleware configuration files.
-  #
-  # The agent will instead now automatically collect errors for all Rack
-  # applications if automatic Rack middleware instrumentation is enabled (it is
-  # by default), or if you have manually added any New Relic middlewares into
-  # your middleware stack.
-  #
-  # @api public
-  # @deprecated
-  #
-  class ErrorCollector < AgentMiddleware
-    def traced_call(env)
-      @app.call(env)
-    end
-  end
-end

data/lib/new_relic/timer_lib.rb

@@ -1,31 +0,0 @@
-# encoding: utf-8
-# This file is distributed under Ruby's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-# Copyright:  (C) 2008 David Vollbracht & Philippe Hanrigou
-
-# This code was borrowed from the system_timer gem under the terms
-# of the Ruby license.  It has been slightly modified.
-
-# Defines the constant TimerLib to the appropriate timeout library
-module NewRelic #:nodoc:
-
-  begin
-    # Try to use the SystemTimer gem instead of Ruby's timeout library
-    # when running on Ruby 1.8.x. See:
-    #   http://ph7spot.com/articles/system_timer
-    # We don't want to bother trying to load SystemTimer on jruby,
-    # ruby 1.9+ and rbx.
-    if !defined?(RUBY_ENGINE) || (RUBY_ENGINE == 'ruby' && RUBY_VERSION < '1.9.0')
-      require 'system_timer'
-      TimerLib = SystemTimer
-    else
-      require 'timeout'
-      TimerLib = Timeout
-    end
-  rescue LoadError
-    require 'timeout'
-    TimerLib = Timeout
-  end
-
-end

data/lib/sequel/extensions/newrelic_instrumentation.rb

@@ -1,79 +0,0 @@
-# -*- ruby -*-
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'sequel' unless defined?( Sequel )
-require 'newrelic_rpm' unless defined?( NewRelic )
-require 'new_relic/agent/instrumentation/sequel_helper'
-require 'new_relic/agent/datastores/metric_helper'
-
-module Sequel
-
-  # New Relic's Sequel instrumentation is implemented via a plugin for
-  # Sequel::Models, and an extension for Sequel::Databases. Every database
-  # handle that Sequel knows about when New Relic is loaded will automatically
-  # be instrumented, but if you're using a version of Sequel before 3.47.0,
-  # you'll need to add the extension yourself if you create any after the
-  # instrumentation is loaded:
-  #
-  #     db = Sequel.connect( ... )
-  #     db.extension :newrelic_instrumentation
-  #
-  # Versions 3.47.0 and later use `Database.extension` to automatically
-  # install the extension for new connections.
-  #
-  # == Disabling
-  #
-  # If you don't want your models or database connections to be instrumented,
-  # you can disable them by setting `disable_database_instrumentation` in
-  # your `newrelic.yml` to `true`. It will also honor the
-  # `disable_activerecord_instrumentation` setting.
-  #
-  module NewRelicInstrumentation
-
-    # Instrument all queries that go through #execute_query.
-    def log_yield(sql, args=nil) #THREAD_LOCAL_ACCESS
-      rval = nil
-      product = NewRelic::Agent::Instrumentation::SequelHelper.product_name_from_adapter(self.class.adapter_scheme)
-      metrics = NewRelic::Agent::Datastores::MetricHelper.metrics_from_sql(product, sql)
-      scoped_metric = metrics.first
-
-      NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
-        t0 = Time.now
-        begin
-          rval = super
-        ensure
-          notice_sql(sql, scoped_metric, args, t0, Time.now)
-        end
-      end
-
-      return rval
-    end
-
-    THREAD_SAFE_CONNECTION_POOL_CLASSES = [
-      (defined?(::Sequel::ThreadedConnectionPool) && ::Sequel::ThreadedConnectionPool)
-    ].freeze
-
-    def notice_sql(sql, metric_name, args, start, finish)
-      state    = NewRelic::Agent::TransactionState.tl_get
-      duration = finish - start
-
-      explainer = Proc.new do |*|
-        if THREAD_SAFE_CONNECTION_POOL_CLASSES.include?(self.pool.class)
-          self[ sql ].explain
-        else
-          NewRelic::Agent.logger.log_once(:info, :sequel_explain_skipped, "Not running SQL explains because Sequel is not in recognized multi-threaded mode")
-          nil
-        end
-      end
-      NewRelic::Agent.instance.transaction_sampler.notice_sql(sql, self.opts, duration, state, &explainer)
-      NewRelic::Agent.instance.sql_sampler.notice_sql(sql, metric_name, self.opts, duration, state, &explainer)
-    end
-
-  end # module NewRelicInstrumentation
-
-  NewRelic::Agent.logger.debug "Registering the :newrelic_instrumentation extension."
-  Database.register_extension(:newrelic_instrumentation, NewRelicInstrumentation)
-
-end # module Sequel

data/lib/sequel/plugins/newrelic_instrumentation.rb

@@ -1,65 +0,0 @@
-# -*- ruby -*-
-# encoding: utf-8
-# This file is distributed under New Relic's license terms.
-# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
-
-require 'sequel' unless defined?( Sequel )
-require 'newrelic_rpm' unless defined?( NewRelic )
-require 'new_relic/agent/instrumentation/sequel_helper'
-require 'new_relic/agent/datastores/metric_helper'
-
-module Sequel
-  module Plugins
-
-    # Sequel::Model instrumentation for the New Relic agent.
-    module NewrelicInstrumentation
-
-      # Meta-programming for creating method tracers for the Sequel::Model plugin.
-      module MethodWrapping
-        # Install a method named +method_name+ that will trace execution
-        # with a metric name derived from +operation_name+ (or +method_name+ if +operation_name+
-        # isn't specified).
-        def wrap_sequel_method(method_name, operation_name=method_name)
-          define_method(method_name) do |*args, &block|
-            klass = self.is_a?(Class) ? self : self.class
-
-            product = NewRelic::Agent::Instrumentation::SequelHelper.product_name_from_adapter(db.adapter_scheme)
-            metrics = ::NewRelic::Agent::Datastores::MetricHelper.metrics_for(product, operation_name, klass.name)
-
-            NewRelic::Agent::MethodTracer.trace_execution_scoped(metrics) do
-              NewRelic::Agent.disable_all_tracing { super(*args, &block) }
-            end
-          end
-        end
-
-      end # module MethodTracer
-
-      # Methods to be added to Sequel::Model instances.
-      module InstanceMethods
-        extend Sequel::Plugins::NewrelicInstrumentation::MethodWrapping
-
-        wrap_sequel_method :delete
-        wrap_sequel_method :destroy
-        wrap_sequel_method :update
-        wrap_sequel_method :update_all
-        wrap_sequel_method :update_except
-        wrap_sequel_method :update_fields
-        wrap_sequel_method :update_only
-        wrap_sequel_method :save
-
-      end # module InstanceMethods
-
-
-      # Methods to be added to Sequel::Model classes.
-      module ClassMethods
-        extend Sequel::Plugins::NewrelicInstrumentation::MethodWrapping
-
-        wrap_sequel_method :[], "get"
-        wrap_sequel_method :all
-        wrap_sequel_method :first
-        wrap_sequel_method :create
-      end # module ClassMethods
-
-    end # module NewRelicInstrumentation
-  end # module Plugins
-end # module Sequel

data/lib/tasks/config.html.erb

@@ -1,28 +0,0 @@
-<% sections.each do |(section_key, section_name, section_description, configs)| %>
-<h2 id="<%=section_key%>"><%=section_name%></h2>
-
-<%= "<p>#{section_description}</p>" unless section_description.nil? %>
-
-<dl class="clamshell-list">
-  <% configs.each do |config|%>
-  <!-- ********** <%= config[:key] %> ********** -->
-  <dt id="<%=config[:key]%>"><%=config[:key]%></dt>
-  <dd>
-  <table class="specs">
-    <tbody>
-      <tr>
-        <th>Type</th>
-        <td><%=config[:type]%></td>
-      </tr>
-      <tr>
-        <th>Default</th>
-        <td><%=config[:default]%></td>
-      </tr>
-    </tbody>
-  </table>
-
-  <p><%=config[:description]%></p>
-  </dd>
-  <% end %>
-</dl>
-<% end %>

data/lib/tasks/config.text.erb

@@ -1,7 +0,0 @@
-<% sections.each do |(section_key, section_name, section_description, configs)| %><% configs.each do |config|%>
-<%=config[:key]%>
-<%=config[:description]%>
-
-Type:    <%=config[:type]%>
-Default: <%=config[:default]%>
-------------------------------<% end %><% end %>

data/lib/tasks/versions.html.erb

@@ -1,27 +0,0 @@
-<h2 id="<%= anchor %>"><%= title %></h2>
-<table>
-  <thead>
-    <th>Name</th>
-    <th>Supported</th>
-    <th>Deprecated</th>
-    <th>Experimental</th>
-  </thead>
-  <% for version in versions %>
-    <tr>
-      <td><b><%= version.name %></b></td>
-      <td><%= version_list(version.supported) %></td>
-      <td><%= version_list(version.deprecated) %></td>
-      <td><%= version_list(version.experimental) %></td>
-    </tr>
-    <% if version.notes %>
-    <tr>
-      <td></td>
-      <td colspan=3>
-        <% for note in version.notes %>
-          <%= note %><br/>
-        <% end %>
-      </td>
-    </tr>
-    <% end %>
-  <% end %>
-</table>

data/lib/tasks/versions.rake

@@ -1,53 +0,0 @@
-namespace :newrelic do
-  desc "Lists information on supported versions of frameworks for this agent"
-
-  require File.join(File.dirname(__FILE__), '..', 'new_relic', 'agent', 'supported_versions')
-
-  task :supported_versions, [:format] => [] do |t, args|
-
-    def version_list(list)
-      return "-" if list.nil? || list.empty?
-      list.join(", ")
-    end
-
-    def versions_for_type(type)
-      NewRelic::Agent::SUPPORTED_VERSIONS.
-        select  {|key, values| values[:type] == type}.
-        sort_by {|key, values| (values[:name] || key).to_s }.
-        map    do |key,values|
-          VersionStruct.new(
-            values[:name] || key,
-            values[:supported],
-            values[:deprecated],
-            values[:experimental],
-            values[:notes])
-        end
-    end
-
-    def build_erb(format)
-      require 'erb'
-      path = File.join(File.dirname(__FILE__), "versions.#{format}.erb")
-      template = File.read(File.expand_path(path))
-      ERB.new(template)
-    end
-
-    def write_versions(title, type, erb)
-      anchor = title.downcase.gsub(" ", "_")
-      versions = versions_for_type(type)
-      puts erb.result(binding).gsub(/^ *$/, '')
-    end
-
-    VersionStruct = Struct.new(:name, :supported, :deprecated, :experimental, :notes)
-
-    format = args[:format] || "txt"
-    erb = build_erb(format)
-
-    write_versions("Ruby Versions",   :ruby, erb)
-    write_versions("Web Servers",     :app_server, erb)
-    write_versions("Web Frameworks",  :web, erb)
-    write_versions("Database",        :database, erb)
-    write_versions("Background Jobs", :background, erb)
-    write_versions("HTTP Clients",    :http, erb)
-    write_versions("Other",           :other, erb)
-  end
-end

data/lib/tasks/versions.txt.erb

@@ -1,14 +0,0 @@
-=========================================
-<%= title %>
-=========================================
-<% for version in versions %>
-<%= version.name %>
-
-Supported:    <%= version_list(version.supported) %>
-Deprecated:   <%= version_list(version.deprecated) %>
-Experimental: <%= version_list(version.experimental) %>
-<% if version.notes %>Notes:<% for note in version.notes %>
-  <%= note %><% end %>
-<% end %>
-------------------------------------
-<% end %>