sundawg_newrelic_rpm 3.5.8.1

data/lib/new_relic/transaction_sample/composite_segment.rb

@@ -0,0 +1,27 @@
+require 'new_relic/transaction_sample'
+require 'new_relic/transaction_sample/segment'
+require 'new_relic/transaction_sample/summary_segment'
+module NewRelic
+  class TransactionSample
+    class CompositeSegment < Segment
+      attr_reader :detail_segments
+
+      def initialize(segments)
+        summary = SummarySegment.new(segments.first)
+        super summary.entry_timestamp, "Repeating pattern (#{segments.length} repeats)", nil
+
+        summary.end_trace(segments.last.exit_timestamp)
+
+        @detail_segments = segments.clone
+
+        add_called_segment(summary)
+        end_trace summary.exit_timestamp
+      end
+
+      def detail_segments=(segments)
+        @detail_segments = segments
+      end
+
+    end
+  end
+end

data/lib/new_relic/transaction_sample/fake_segment.rb

@@ -0,0 +1,9 @@
+require 'new_relic/transaction_sample'
+require 'new_relic/transaction_sample/segment'
+module NewRelic
+  class TransactionSample
+    class FakeSegment < Segment
+      public :parent_segment=
+    end
+  end
+end

data/lib/new_relic/transaction_sample/segment.rb

@@ -0,0 +1,205 @@
+require 'new_relic/transaction_sample'
+
+module NewRelic
+  class TransactionSample
+    class Segment
+      attr_reader :entry_timestamp
+      # The exit timestamp will be relative except for the outermost sample which will
+      # have a timestamp.
+      attr_reader :exit_timestamp
+      attr_reader :parent_segment
+      attr_reader :segment_id
+
+      attr_accessor :metric_name
+
+      def initialize(timestamp, metric_name, segment_id)
+        @entry_timestamp = timestamp
+        @metric_name = metric_name || '<unknown>'
+        @segment_id = segment_id || object_id
+      end
+
+      # sets the final timestamp on a segment to indicate the exit
+      # point of the segment
+      def end_trace(timestamp)
+        @exit_timestamp = timestamp
+      end
+
+      def add_called_segment(s)
+        @called_segments ||= []
+        @called_segments << s
+        s.parent_segment = self
+      end
+
+      def to_s
+        to_debug_str(0)
+      end
+
+      include NewRelic::Coerce
+
+      def to_array
+        [ NewRelic::Helper.time_to_millis(@entry_timestamp),
+          NewRelic::Helper.time_to_millis(@exit_timestamp),
+          string(@metric_name),
+          (@params || {}) ] +
+          [ (@called_segments ? @called_segments.map{|s| s.to_array} : []) ]
+      end
+
+      def to_json
+        JSON.dump(self.to_array)
+      end
+
+      def path_string
+        "#{metric_name}[#{called_segments.collect {|segment| segment.path_string }.join('')}]"
+      end
+      def to_s_compact
+        str = ""
+        str << metric_name
+        if called_segments.any?
+          str << "{#{called_segments.map { | cs | cs.to_s_compact }.join(",")}}"
+        end
+        str
+      end
+      def to_debug_str(depth)
+        tab = "  " * depth
+        s = tab.clone
+        s << ">> #{'%3i ms' % (@entry_timestamp*1000)} [#{self.class.name.split("::").last}] #{metric_name} \n"
+        unless params.empty?
+          params.each do |k,v|
+            s << "#{tab}    -#{'%-16s' % k}: #{v.to_s[0..80]}\n"
+          end
+        end
+        called_segments.each do |cs|
+          s << cs.to_debug_str(depth + 1)
+        end
+        s << tab + "<< "
+        s << case @exit_timestamp
+             when nil then ' n/a'
+             when Numeric then '%3i ms' % (@exit_timestamp*1000)
+             else @exit_timestamp.to_s
+             end
+        s << " #{metric_name}\n"
+      end
+
+      def called_segments
+        @called_segments || []
+      end
+
+      # return the total duration of this segment
+      def duration
+        (@exit_timestamp - @entry_timestamp).to_f
+      end
+
+      # return the duration of this segment without
+      # including the time in the called segments
+      def exclusive_duration
+        d = duration
+
+        called_segments.each do |segment|
+          d -= segment.duration
+        end
+        d
+      end
+
+      def count_segments
+        count = 1
+        called_segments.each { | seg | count  += seg.count_segments }
+        count
+      end
+
+      # Walk through the tree and truncate the segments in a
+      # depth-first manner
+      def truncate(max)
+        return 1 unless @called_segments
+        total, self.called_segments = truncate_each_child(max - 1)
+        total+1
+      end
+
+      def truncate_each_child(max)
+        total = 0
+        accumulator = []
+        called_segments.each { | s |
+          if total == max
+            true
+          else
+            total += s.truncate(max - total)
+            accumulator << s
+          end
+        }
+        total
+        [total, accumulator]
+      end
+
+      def []=(key, value)
+        # only create a parameters field if a parameter is set; this will save
+        # bandwidth etc as most segments have no parameters
+        params[key] = value
+      end
+
+      def [](key)
+        params[key]
+      end
+
+      def params
+        @params ||= {}
+      end
+
+      # call the provided block for this segment and each
+      # of the called segments
+      def each_segment(&block)
+        block.call self
+
+        if @called_segments
+          @called_segments.each do |segment|
+            segment.each_segment(&block)
+          end
+        end
+      end
+
+      # call the provided block for this segment and each
+      # of the called segments while keeping track of nested segments
+      def each_segment_with_nest_tracking(&block)
+        summary = block.call self
+        summary.current_nest_count += 1 if summary
+
+        if @called_segments
+          @called_segments.each do |segment|
+            segment.each_segment_with_nest_tracking(&block)
+          end
+        end
+
+        summary.current_nest_count -= 1 if summary
+      end
+
+      def find_segment(id)
+        return self if @segment_id == id
+        called_segments.each do |segment|
+          found = segment.find_segment(id)
+          return found if found
+        end
+        nil
+      end
+      
+      def explain_sql
+        NewRelic::Agent::Database.explain_sql(params[:sql],
+                                              params[:connection_config])
+      end
+      
+      def obfuscated_sql
+        NewRelic::Agent::Database.obfuscate_sql(params[:sql])
+      end
+      
+      def params=(p)
+        @params = p
+      end
+
+      def called_segments=(segments)
+        @called_segments = segments
+      end
+
+      protected
+      def parent_segment=(s)
+        @parent_segment = s
+      end
+    end
+  end
+end

data/lib/new_relic/transaction_sample/summary_segment.rb

@@ -0,0 +1,21 @@
+require 'new_relic/transaction_sample'
+require 'new_relic/transaction_sample/segment'
+module NewRelic
+  class TransactionSample
+    class SummarySegment < Segment
+      def initialize(segment)
+        super segment.entry_timestamp, segment.metric_name, nil
+
+        add_segments segment.called_segments
+
+        end_trace segment.exit_timestamp
+      end
+
+      def add_segments(segments)
+        segments.collect do |segment|
+          SummarySegment.new(segment)
+        end.each {|segment| add_called_segment(segment)}
+      end
+    end
+  end
+end

data/lib/new_relic/url_rule.rb

@@ -0,0 +1,14 @@
+# Represents url mapping rules stored on the server.  These rules should be applied
+# to URLs which are not normalized into controller class/action by Rails routes.
+# Insantiated strictly by Marshal.
+class NewRelic::UrlRule
+  attr_reader :match_expression, :replacement, :eval_order, :terminate_chain
+
+  def apply url
+    return nil
+  end
+
+  class RuleSet
+
+  end
+end

data/lib/new_relic/version.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/ruby
+
+module NewRelic
+  module VERSION #:nodoc:
+    def self.build_version_string(*parts)
+      parts.compact.join('.')
+    end
+
+    MAJOR = 3
+    MINOR = 5
+    TINY  = 8
+
+    begin
+      require File.join(File.dirname(__FILE__), 'build')
+    rescue LoadError => e
+      BUILD = nil
+    end
+
+    STRING = build_version_string(MAJOR, MINOR, TINY, BUILD)
+  end
+
+  # Helper class for managing version comparisons
+  class VersionNumber
+    attr_reader :parts
+    include Comparable
+    def initialize(version_string)
+      version_string ||= '1.0.0'
+      @parts = version_string.split('.').map{|n| n =~ /^\d+$/ ? n.to_i : n}
+    end
+    def major_version; @parts[0]; end
+    def minor_version; @parts[1]; end
+    def tiny_version; @parts[2]; end
+
+    def <=>(other)
+      other = self.class.new(other) if other.is_a? String
+      self.class.compare(self.parts, other.parts)
+    end
+
+    def to_s
+      @parts.join(".")
+    end
+
+    def hash
+      @parts.hash
+    end
+
+    def eql? other
+      (self <=> other) == 0
+    end
+
+    private
+    def self.compare(parts1, parts2)
+      a, b = parts1.first, parts2.first
+      case
+        when a.nil? && b.nil? then 0
+        when a.nil? then b.is_a?(Fixnum) ?  -1 : 1
+        when b.nil? then -compare(parts2, parts1)
+        when a.to_s == b.to_s then compare(parts1[1..-1], parts2[1..-1])
+        when a.is_a?(String) then b.is_a?(Fixnum) ?  -1 : (a <=> b)
+        when b.is_a?(String) then -compare(parts2, parts1)
+        else # they are both fixnums, not nil
+          a <=> b
+      end
+    end
+  end
+end

data/lib/newrelic_rpm.rb

@@ -0,0 +1,49 @@
+# == New Relic Initialization
+#
+# When installed as a gem, you can activate the New Relic agent one of the following ways:
+#
+# For Rails, add:
+#    config.gem 'newrelic_rpm'
+# to your initialization sequence.
+#
+# For merb, do
+#    dependency 'newrelic_rpm'
+# in the Merb config/init.rb
+#
+# For Sinatra, do
+#    require 'newrelic_rpm'
+# after requiring 'sinatra'.
+#
+# For other frameworks, or to manage the agent manually, invoke NewRelic::Agent#manual_start
+# directly.
+#
+require 'new_relic/control'
+if defined?(Merb) && defined?(Merb::BootLoader)
+  module NewRelic
+    class MerbBootLoader < Merb::BootLoader
+      after Merb::BootLoader::ChooseAdapter
+      def self.run
+        NewRelic::Control.instance.init_plugin
+      end
+    end
+  end
+elsif defined? Rails
+  if Rails.respond_to?(:version) && Rails.version > '3'
+    module NewRelic
+      class Railtie < Rails::Railtie
+
+        initializer "newrelic_rpm.start_plugin" do |app|
+	  NewRelic::Control.instance.init_plugin(:config => app.config)
+        end
+      end
+    end
+  else
+    # After verison 2.0 of Rails we can access the configuration directly.
+    # We need it to add dev mode routes after initialization finished.
+    config = nil
+    config = Rails.configuration if Rails.respond_to?(:configuration)
+    NewRelic::Control.instance.init_plugin :config => config
+  end
+else
+  NewRelic::Control.instance.init_plugin
+end

data/lib/tasks/all.rb

@@ -0,0 +1,4 @@
+# This is required to load in task definitions from merb
+Dir.glob(File.join(File.dirname(__FILE__),'*.rake')) do |file|
+  load file
+end

data/lib/tasks/install.rake

@@ -0,0 +1,7 @@
+# run unit tests for the NewRelic Agent
+namespace :newrelic do
+  desc "install a default config/newrelic.yml file"
+  task :install do
+    load File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "install.rb"))  
+  end
+end

data/lib/tasks/tests.rake

@@ -0,0 +1,17 @@
+begin
+  require 'rake/testtask'
+rescue LoadError => e
+end
+
+if defined? Rake::TestTask
+  namespace :test do
+    agent_home = File.expand_path(File.join(File.dirname(__FILE__),'..','..'))
+
+    Rake::TestTask.new(:newrelic) do |t|
+      t.libs << "#{agent_home}/test"
+      t.libs << "#{agent_home}/lib"
+      t.pattern = "#{agent_home}/test/new_relic/**/*_test.rb"
+      t.verbose = true
+    end
+  end
+end

data/newrelic.yml

@@ -0,0 +1,227 @@
+#
+# This file configures the New Relic Ruby Agent, New Relic monitors
+# Rails applications with deep visibility and low overhead. For more
+# information, visit www.newrelic.com.
+#
+# Generated <%= Time.now.strftime('%B %d, %Y') %>, for version <%= NewRelic::VERSION::STRING %>
+#
+# <%= generated_for_user %>
+
+
+# Here are the settings that are common to all environments
+common: &default_settings
+  # ============================== LICENSE KEY ===============================
+
+  # You must specify the license key associated with your New Relic
+  # account.  This key binds your Agent's data to your account in the
+  # New Relic service.
+  license_key: '<%= license_key %>'
+
+  # Agent Enabled (Rails Only)
+  # Use this setting to force the agent to run or not run.
+  # Default is 'auto' which means the agent will install and run only
+  # if a valid dispatcher such as Mongrel is running.  This prevents
+  # it from running with Rake or the console. Set to false to
+  # completely turn the agent off regardless of the other settings.
+  # Valid values are true, false and auto.
+  #
+  # agent_enabled: auto
+
+  # Application Name Set this to be the name of your application as
+  # you'd like it show up in New Relic. The service will then auto-map
+  # instances of your application into an "application" on your
+  # dashboard page. If you want to map this instance into multiple
+  # apps, like "AJAX Requests" and "All UI" then specify a semicolon
+  # separated list of up to three distinct names, or a yaml list.
+  # Defaults to the capitalized RAILS_ENV or RACK_ENV (i.e.,
+  # Production, Staging, etc)
+  #
+  # Example:
+  #
+  #   app_name:
+  #       - Ajax Service
+  #       - All Services
+  #
+  app_name: <%= @app_name %>
+
+  # When "true", the agent collects performance data about your
+  # application and reports this data to the New Relic service at
+  # newrelic.com. This global switch is normally overridden for each
+  # environment below (formerly called 'enabled').
+  monitor_mode: true
+
+  # Developer mode should be off in every environment but
+  # development as it has very high overhead in memory.
+  developer_mode: false
+
+  # The newrelic agent generates its own log file to keep its logging
+  # information separate from that of your application. Specify its
+  # log level here.
+  log_level: info
+
+  # Optionally set the path to the log file This is expanded from the
+  # root directory (may be relative or absolute, e.g. 'log/' or
+  # '/var/log/') The agent will attempt to create this directory if it
+  # does not exist.
+  # log_file_path: 'log'
+
+  # Optionally set the name of the log file, defaults to 'newrelic_agent.log'
+  # log_file_name: 'newrelic_agent.log'
+
+  # The newrelic agent communicates with the service via https by default.  This
+  # prevents eavesdropping on the performance metrics transmitted by the agent.
+  # The encryption required by SSL introduces a nominal amount of CPU overhead,
+  # which is performed asynchronously in a background thread.  If you'd prefer
+  # to send your metrics over http uncomment the following line.
+  # ssl: false
+
+  #============================== Browser Monitoring ===============================
+  # New Relic Real User Monitoring gives you insight into the performance real users are
+  # experiencing with your website. This is accomplished by measuring the time it takes for
+  # your users' browsers to download and render your web pages by injecting a small amount
+  # of JavaScript code into the header and footer of each page.
+  browser_monitoring:
+      # By default the agent automatically injects the monitoring JavaScript
+      # into web pages. Set this attribute to false to turn off this behavior.
+      auto_instrument: true
+
+  # Proxy settings for connecting to the service.
+  #
+  # If a proxy is used, the host setting is required.  Other settings
+  # are optional. Default port is 8080.
+  #
+  # proxy_host: hostname
+  # proxy_port: 8080
+  # proxy_user:
+  # proxy_pass:
+
+  # The agent can optionally log all data it sends to New Relic servers to a
+  # separate log file for human inspection and auditing purposes. To enable this
+  # feature, change 'enabled' below to true.
+  # See: https://newrelic.com/docs/ruby/audit-log
+  audit_log:
+    enabled: false
+
+  # Tells transaction tracer and error collector (when enabled)
+  # whether or not to capture HTTP params.  When true, frameworks can
+  # exclude HTTP parameters from being captured.
+  # Rails: the RoR filter_parameter_logging excludes parameters
+  # Java: create a config setting called "ignored_params" and set it to
+  #     a comma separated list of HTTP parameter names.
+  #     ex: ignored_params: credit_card, ssn, password 
+  capture_params: false
+
+  # Transaction tracer captures deep information about slow
+  # transactions and sends this to the service once a
+  # minute. Included in the transaction is the exact call sequence of
+  # the transactions including any SQL statements issued.
+  transaction_tracer:
+
+    # Transaction tracer is enabled by default. Set this to false to
+    # turn it off. This feature is only available at the Professional
+    # and above product levels.
+    enabled: true
+
+    # Threshold in seconds for when to collect a transaction
+    # trace. When the response time of a controller action exceeds
+    # this threshold, a transaction trace will be recorded and sent to
+    # the service. Valid values are any float value, or (default)
+    # "apdex_f", which will use the threshold for an dissatisfying
+    # Apdex controller action - four times the Apdex T value.
+    transaction_threshold: apdex_f
+
+    # When transaction tracer is on, SQL statements can optionally be
+    # recorded. The recorder has three modes, "off" which sends no
+    # SQL, "raw" which sends the SQL statement in its original form,
+    # and "obfuscated", which strips out numeric and string literals.
+    record_sql: obfuscated
+
+    # Threshold in seconds for when to collect stack trace for a SQL
+    # call. In other words, when SQL statements exceed this threshold,
+    # then capture and send the current stack trace. This is
+    # helpful for pinpointing where long SQL calls originate from.
+    stack_trace_threshold: 0.500
+
+    # Determines whether the agent will capture query plans for slow
+    # SQL queries.  Only supported in mysql and postgres.  Should be
+    # set to false when using other adapters.
+    # explain_enabled: true
+
+    # Threshold for query execution time below which query plans will not
+    # not be captured.  Relevant only when `explain_enabled` is true.
+    # explain_threshold: 0.5
+
+  # Error collector captures information about uncaught exceptions and
+  # sends them to the service for viewing.
+  error_collector:
+
+    # Error collector is enabled by default. Set this to false to turn
+    # it off. This feature is only available at the Professional and above
+    # product levels.
+    enabled: true
+
+    # Rails Only - tells error collector whether or not to capture a
+    # source snippet around the place of the error when errors are View
+    # related.
+    capture_source: true
+
+    # To stop specific errors from reporting to New Relic, set this property
+    # to comma separated values.  Default is to ignore routing errors
+    # which are how 404's get triggered.
+    ignore_errors: ActionController::RoutingError
+
+  # If you're interested in capturing memcache keys as though they
+  # were SQL uncomment this flag. Note that this does increase
+  # overhead slightly on every memcached call, and can have security
+  # implications if your memcached keys are sensitive
+  # capture_memcache_keys: true
+
+# Application Environments
+# ------------------------------------------
+# Environment specific settings are in this section.
+# For Rails applications, RAILS_ENV is used to determine the environment
+# For Java applications, pass -Dnewrelic.environment <environment> to set
+# the environment
+
+# NOTE if your application has other named environments, you should
+# provide newrelic configuration settings for these environments here.
+
+development:
+  <<: *default_settings
+  # Turn off communication to New Relic service in development mode (also
+  # 'enabled').
+  # NOTE: for initial evaluation purposes, you may want to temporarily
+  # turn the agent on in development mode.
+  monitor_mode: false
+
+  # Rails Only - when running in Developer Mode, the New Relic Agent will
+  # present performance information on the last 100 transactions you have
+  # executed since starting the mongrel.
+  # NOTE: There is substantial overhead when running in developer mode.
+  # Do not use for production or load testing.
+  developer_mode: true
+
+  # Enable textmate links
+  # textmate: true
+
+test:
+  <<: *default_settings
+  # It almost never makes sense to turn on the agent when running
+  # unit, functional or integration tests or the like.
+  monitor_mode: false
+
+# Turn on the agent in production for 24x7 monitoring. NewRelic
+# testing shows an average performance impact of < 5 ms per
+# transaction, you can leave this on all the time without
+# incurring any user-visible performance degradation.
+production:
+  <<: *default_settings
+  monitor_mode: true
+
+# Many applications have a staging environment which behaves
+# identically to production. Support for that environment is provided
+# here.  By default, the staging environment has the agent turned on.
+staging:
+  <<: *default_settings
+  monitor_mode: true
+  app_name: <%= @app_name %> (Staging)