ghazel-newrelic_rpm 3.1.0.1

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,251 @@
+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 :metric_name
+      attr_reader :segment_id
+
+      def initialize(timestamp, metric_name, segment_id)
+        @entry_timestamp = timestamp
+        @metric_name = metric_name || '<unknown>'
+        @segment_id = segment_id || object_id
+      end
+
+      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
+
+      def to_json
+        hash = {
+          :entry_timestamp => @entry_timestamp,
+          :exit_timestamp => @exit_timestamp,
+          :metric_name => @metric_name,
+          :segment_id => @segment_id,
+        }
+
+        hash[:called_segments] = called_segments if !called_segments.empty?
+        hash[:params] = @params if @params && !@params.empty?
+
+        hash.to_json
+      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
+      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
+
+      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
+
+      # Perform this in the runtime environment of a managed
+      # application, to explain the sql statement(s) executed within a
+      # segment of a transaction sample. Returns an array of
+      # explanations (which is an array rows consisting of an array of
+      # strings for each column returned by the the explain query)
+      # Note this happens only for statements whose execution time
+      # exceeds a threshold (e.g. 500ms) and only within the slowest
+      # transaction in a report period, selected for shipment to New
+      # Relic
+      def explain_sql
+        sql = params[:sql]
+        return nil unless sql && params[:connection_config]
+        statements = sql.split(";\n")
+        statements.map! do |statement|
+          # a small sleep to make sure we yield back to the parent
+          # thread regularly, if there are many explains
+          sleep(0.0001)
+          explain_statement(statement, params[:connection_config])
+        end
+        statements.compact!
+        statements
+      end
+
+      def explain_statement(statement, config)
+        if is_select?(statement)
+          handle_exception_in_explain do
+            connection = NewRelic::TransactionSample.get_connection(config)
+            process_resultset(connection.execute("EXPLAIN #{statement}")) if connection
+          end
+        end
+      end
+
+      def is_select?(statement)
+        # split the string into at most two segments on the
+        # system-defined field separator character
+        first_word, rest_of_statement = statement.split($;, 2)
+        (first_word.upcase == 'SELECT')
+      end
+
+      def process_resultset(items)
+        # The resultset type varies for different drivers.  Only thing you can count on is
+        # that it implements each.  Also: can't use select_rows because the native postgres
+        # driver doesn't know that method.
+
+        if items.respond_to?(:each)
+          rows = []
+          items.each do |row|
+            columns = []
+            row.each do |column|
+              columns << column.to_s
+            end
+            rows << columns
+          end
+          rows
+        else
+          [items]
+        end
+      end
+
+
+      def handle_exception_in_explain
+        yield
+      rescue Exception => e
+        begin
+          # guarantees no throw from explain_sql
+          NewRelic::Control.instance.log.error("Error getting explain plan: #{e.message}")
+          NewRelic::Control.instance.log.debug(e.backtrace.join("\n"))
+        rescue Exception
+          # double exception. throw up your hands
+        end
+      end
+
+
+      def params=(p)
+        @params = p
+      end
+
+      def obfuscated_sql
+        TransactionSample.obfuscate_sql(params[:sql])
+      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,55 @@
+#!/usr/bin/ruby
+module NewRelic
+  module VERSION #:nodoc:
+    MAJOR = 3
+    MINOR = 1
+    TINY  = 0
+    BUILD = nil #'0' # Set to nil for a release, 'beta1', 'alpha', etc for prerelease builds
+    STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
+  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
+  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,19 @@
+# run unit tests for the NewRelic Agent
+begin
+  require 'rake/test_task'
+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/**/*_test.rb"
+      t.verbose = true
+    end
+    Rake::Task['test:newrelic'].comment = "Run the unit tests for the Agent"
+    task :newrelic => :environment
+  end
+end

data/newrelic.yml

@@ -0,0 +1,265 @@
+#
+# 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 http by
+  # default.  If you want to communicate via https to increase
+  # security, then turn on SSL by setting this value to true.  Note,
+  # this will result in increased CPU overhead to perform the
+  # encryption involved in SSL communication, but this work is done
+  # asynchronously to the threads that process your application code,
+  # so it should not impact response times.
+  ssl: false
+
+  # EXPERIMENTAL: enable verification of the SSL certificate sent by
+  # the server. This setting has no effect unless SSL is enabled
+  # above. This may block your application. Only enable it if the data
+  # you send us needs end-to-end verified certificates.
+  #
+  # This means we cannot cache the DNS lookup, so each request to the
+  # service will perform a lookup. It also means that we cannot
+  # use a non-blocking lookup, so in a worst case, if you have DNS
+  # problems, your app may block indefinitely.
+  # verify_certificate: true
+  
+  # Set your application's Apdex threshold value with the 'apdex_t'
+  # setting, in seconds. The apdex_t value determines the buckets used
+  # to compute your overall Apdex score. 
+  # Requests that take less than apdex_t seconds to process will be
+  # classified as Satisfying transactions; more than apdex_t seconds
+  # as Tolerating transactions; and more than four times the apdex_t
+  # value as Frustrating transactions. 
+  # For more about the Apdex standard, see
+  # http://support.newrelic.com/faqs/general/apdex
+
+  apdex_t: 0.5
+  
+  #============================== 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:
+
+  
+  # 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
+
+  # (Advanced) Uncomment this to ensure the cpu and memory samplers
+  # won't run.  Useful when you are using the agent to monitor an
+  # external resource
+  # disable_samplers: true
+  
+  # If you aren't interested in visibility in these areas, you can
+  # disable the instrumentation to reduce overhead.
+  #
+  # disable_view_instrumentation: true
+  # disable_activerecord_instrumentation: true
+  # disable_memcache_instrumentation: true
+  # disable_dj: true
+
+  # 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
+  
+  # Certain types of instrumentation such as GC stats will not work if 
+  # you are running multi-threaded.  Please let us know.
+  # multi_threaded = false
+
+# 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 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)