ghazel-newrelic_rpm 3.1.0.1 → 3.4.0.2

data/lib/new_relic/agent/samplers/delayed_job_lock_sampler.rb

@@ -1,40 +0,0 @@
-require 'new_relic/agent/sampler'
-require 'new_relic/delayed_job_injection'
-
-module NewRelic
-  module Agent
-    module Samplers
-      class DelayedJobLockSampler < NewRelic::Agent::Sampler
-        def initialize
-          super :delayed_job_lock
-          raise Unsupported, "DJ instrumentation disabled" if NewRelic::Control.instance['disable_dj']
-          raise Unsupported, "No DJ worker present" unless NewRelic::DelayedJobInjection.worker_name
-        end
-
-        def stats
-          stats_engine.get_stats("Custom/DJ Locked Jobs", false)
-        end
-
-        def local_env
-          NewRelic::Control.instance.local_env
-        end
-
-        def worker_name
-          local_env.dispatcher_instance_id
-        end
-
-        def locked_jobs
-          Delayed::Job.count(:conditions => {:locked_by => NewRelic::DelayedJobInjection.worker_name})
-        end
-
-        def self.supported_on_this_platform?
-          defined?(Delayed::Job)
-        end
-
-        def poll
-          stats.record_data_point locked_jobs
-        end
-      end
-    end
-  end
-end

data/lib/new_relic/data_serialization.rb

@@ -1,84 +0,0 @@
-require 'fileutils'
-module NewRelic
-  class DataSerialization
-    module ClassMethods
-      def should_send_data?
-        NewRelic::Control.instance.disable_serialization? || (File.size(file_path) >= max_size)
-      rescue Exception => e
-        # This is not what we really should do here, but the fail-safe
-        # behavior is to do what the older agent did: send data every
-        # time we think we might want to send data.
-        true
-      end
-      
-      def read_and_write_to_file
-        with_locked_store do |f|
-          result = (yield get_data_from_file(f))
-          f.rewind
-          f.write(dump(result)) if result
-        end
-      end
-
-      private
-
-      def open_arguments
-        if defined?(Encoding)
-          [file_path, File::RDWR | File::CREAT, {:internal_encoding => nil}]
-        else
-          [file_path, File::RDWR | File::CREAT]
-        end
-      end
-      
-      def with_locked_store
-        File.open(*open_arguments) do |f|
-          f.flock(File::LOCK_EX)
-          begin
-            yield(f)
-          ensure
-            f.flock(File::LOCK_UN)
-          end
-        end
-      rescue Exception => e
-        NewRelic::Control.instance.log.error("Error serializing data to disk: #{e.inspect}")
-        NewRelic::Control.instance.log.debug(e.backtrace.split("\n"))
-      end
-
-      def get_data_from_file(f)
-        data = f.read
-        result = load(data)
-        f.truncate(0)
-        result
-      end
-      
-      def max_size
-        10_000
-      end
-
-      def create_file_if_needed
-        FileUtils.touch(file_path) unless File.exists?(file_path)
-      end
-
-      def dump(object)
-        Marshal.dump(object)
-      end
-
-      def load(dump)
-        Marshal.load(dump)
-      rescue ArgumentError => e
-        nil
-      end
-
-      def truncate_file
-        create_file_if_needed
-        File.truncate(file_path, 0)
-      end
-
-      def file_path
-        # TODO get configuration from main control
-        './log/newrelic_agent_store.db'
-      end
-    end
-    extend ClassMethods
-  end
-end
-

data/lib/new_relic/histogram.rb

@@ -1,91 +0,0 @@
-# Histogram is used for organizing response times
-# into an 'Exponential Histogram'.  Feature based in part on DHH proposal:
-# http://37signals.com/svn/posts/1836-the-problem-with-averages
-#
-# Histogram builds a set of buckets of geometrically growing size, with the assumption that most
-# apps have long-tail response times, and therefore you need the most granularity at the lowest
-# r/t level.
-module NewRelic
-  class Histogram
-
-    # Used to stub out API methods when the agent is not enabled
-    module Shim
-      def process(response_time); end
-    end
-    # Stores statistics for response times falling in a particular range.
-    # A bucket has a min and max response time.  A response time event
-    # falls in a bucket if min <= r/t < max.  A bucket also
-    # has an associated metric for reporting data to New Relic.  The
-    # bucket range is encoded in the metic name
-    class Bucket
-
-      attr_reader :min, :max, :stats
-
-      def initialize(min, max = nil)
-        @min = min
-        @max = max
-      end
-
-      def stats
-        NewRelic::Agent.get_stats("Response Times/#{min_millis}/#{max_millis}")
-      end
-
-      # This has return value like <=> but does something more
-      # than simply compare.  If the value falls within range for
-      # the bucket, increment count and return 0; otherwise return
-      # a value < 0 if the value belongs in a bucket with a lower range
-      # you can guess what it returns if the value belongs in a bucket
-      # with a higher range. (Hint: it's not 0, and it's not less than zero.)
-      def process(value)
-        if value < min
-          return -1
-
-          # max == nil means unlimited max (last bucket)
-        elsif max && value >= max
-          return 1
-
-        else
-          stats.record_data_point(value)
-          return 0
-        end
-      end
-
-      def min_millis
-        (min * 1000).round
-      end
-
-      def max_millis
-        max.nil? ? nil : (max * 1000).round
-      end
-
-      def to_s
-        "#{min_millis} - #{max_millis}: #{stats.call_count}"
-      end
-    end
-
-    attr_reader :buckets
-
-    # Histogram uses apdex T / 10 as its minimum bucket size, and grows from there.
-    # 30 data points should be adequate resolution.
-    def initialize(first_bucket_max = 0.010, bucket_count = 30, multiplier = 1.3)
-      @buckets = []
-
-      min = 0
-      max = first_bucket_max
-
-      (bucket_count - 1).times do
-        @buckets << Bucket.new(min, max)
-        min = max
-        max *= multiplier
-      end
-      @buckets << Bucket.new(max)
-    end
-
-    def process(response_time)
-      buckets.each do |bucket|
-        found = bucket.process(response_time)
-        return if found == 0
-      end
-    end
-  end
-end

data/lib/new_relic/rack/metric_app.rb

@@ -1,65 +0,0 @@
-require 'fileutils'
-module NewRelic
-  module Rack
-    class MetricApp
-      def initialize(options)
-        if options[:install]
-          src = File.join(File.dirname(__FILE__), "newrelic.yml")
-          require 'new_relic/command'
-          begin
-            NewRelic::Command::Install.new(:quiet => true, :src_file => src).run
-            NewRelic::Agent.logger.info "A newrelic.yml template was copied to #{File.expand_path('.')}."
-            NewRelic::Agent.logger.info "Please add a license key to the file and restart #{$0}"
-            exit 0
-          rescue NewRelic::Command::CommandFailure => e
-            NewRelic::Agent.logger.error e.message
-            exit 1
-          end
-        end
-        options[:app_name] ||= 'EPM Monitor'
-        options[:disable_samplers] = true
-        NewRelic::Agent.manual_start options
-        NewRelic::Agent.logger.warn "This rack app is deprecated - it will be removed in the next version of the Ruby Agent"
-        unless NewRelic::Control.instance.license_key
-          raise "Please add a valid license key to newrelic.yml."
-        end
-      end
-      def call(env)
-        request = ::Rack::Request.new env
-        params = request.params
-        if !(params['uri'] || params['metric'])
-          [400, { 'Content-Type' => 'text/plain' },  "Missing 'uri' or 'metric' parameter: #{params.inspect}" ]
-        elsif !params['value']
-          [400, { 'Content-Type' => 'text/plain' },  "Missing 'value' parameter: #{params.inspect}" ]
-        else
-          NewRelic::Agent.record_transaction( params['value'].to_f, params )
-          ::Rack::Response.new(params.collect { |k, v| "#{k}=#{v} " }.join).finish
-        end
-      end
-    end
-    class Status
-      def call(env)
-        request = ::Rack::Request.new env
-        data_url = "http://#{env['HTTP_HOST']}/metrics/path?value=nnn"
-        body = StringIO.new
-        body.puts "<html><body>"
-        body.puts "<h1>New Relic Actively Monitoring #{NewRelic::Control.instance.app_names.join(' and ')}</h1>"
-        body.puts "<p>To submit a metric value, use <a href='#{data_url}'>#{data_url}</a></p>"
-        body.puts "<h2>Request Details</h2>"
-        body.puts "<dl>"
-        body.puts "<dt>ip<dd>#{request.ip}"
-        body.puts "<dt>host<dd>#{request.host}"
-        body.puts "<dt>path<dd>#{request.url}"
-        body.puts "<dt>query<dd>#{request.query_string}"
-        body.puts "<dt>params<dd>#{request.params.inspect}"
-        body.puts "</dl>"
-        body.puts "<h2>Complete ENV</h2>"
-        body.puts "<ul>"
-        body.puts env.to_a.map{|k,v| "<li>#{k} = #{v}</li>" }.join("\n")
-        body.puts "</ul></body></html>"
-        response = ::Rack::Response.new body.string
-        response.finish
-      end
-    end
-  end
-end

data/lib/new_relic/rack/mongrel_rpm.ru

@@ -1,28 +0,0 @@
-# This is so that we don't detect a dispatcher like mongrel and think we are
-# monitoring it.
-ENV['NEWRELIC_DISPATCHER'] = 'none'
-
-$LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), '..','..'))
-
-require 'new_relic/rack_app'
-
-# Valid options which may be present in this binding:
-# :license_key   optional license key override
-# :app_name      optional name of app
-# :logging       optional, false to omit request logging to stdout
-
-# use Rack::CommonLogger unless options[:logging] == false
-# use Rack::ShowExceptions
-# use Rack::Reloader if ENV['RACK_ENV'] == 'development'
-
-puts "This Rack Metric Collection system is deprecated - it will be removed in the next version of the Ruby Agent"
-
-map "/newrelic/record_value" do
-  run NewRelic::Rack::MetricApp.new(options)
-end
-
-map "/" do
-  run NewRelic::Rack::Status.new
-end
-
-

data/lib/new_relic/rack/newrelic.yml

@@ -1,27 +0,0 @@
-#
-# This file configures the Rack NewRelic Metric Application.  Place a copy of this file
-# in the directory where you start the mongrel_rpm process.
-#
-# <%= generated_for_user %>
-#
-common: &default_settings
-  log_level: info
-  enabled: true
-  
-  # This is the key generated by script/create_admin
-  license_key: '<%= license_key %>'
-  
-  # Replace this with the name of the application feeding
-  # metrics into the Metric application;
-  app_name: Application Monitor
-    
-# Set RACK_ENV to one of the following:
-
-production:
-  <<: *default_settings
-  app_name: Production Monitor
-  
-staging:
-  <<: *default_settings
-  app_name: Staging Monitor
-

data/lib/new_relic/rack_app.rb

@@ -1,6 +0,0 @@
-require 'rack/response'
-require 'newrelic_rpm'
-
-# Rack middlewares and applications used by New Relic
-require 'new_relic/rack/metric_app'
-require 'new_relic/rack/developer_mode'

data/test/new_relic/data_serialization_test.rb

@@ -1,70 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..', 'test_helper'))
-require 'new_relic/data_serialization'
-class NewRelic::DataSerializationTest < Test::Unit::TestCase
-  def test_read_and_write_from_file_read_only
-    file = './log/newrelic_agent_store.db'
-    File.open(file, 'w') do |f|
-      f.write(Marshal.dump('a happy string'))
-    end
-    NewRelic::DataSerialization.read_and_write_to_file do |data|
-      assert_equal('a happy string', data, "should pull the dumped item from the file")
-      nil # must explicitly return nil or the return value will be dumped
-    end
-    assert_equal(0, File.size(file), "Should not leave any data in the file")
-  end
-
-  def test_read_and_write_to_file_dumping_contents
-    file = './log/newrelic_agent_store.db'
-    expected_contents = Marshal.dump('a happy string')
-    NewRelic::DataSerialization.read_and_write_to_file do
-      'a happy string'
-    end
-    assert_equal(expected_contents, File.read(file), "should have dumped the contents")
-  end
-
-  def test_read_and_write_to_file_yields_old_data
-    file = './log/newrelic_agent_store.db'
-    expected_contents = 'a happy string'
-    File.open(file, 'w') do |f|
-      f.write(Marshal.dump(expected_contents))
-    end
-    contents = nil
-    NewRelic::DataSerialization.read_and_write_to_file do |old_data|
-      contents = old_data
-      'a happy string'
-    end
-    assert_equal(contents, expected_contents, "should have dumped the contents")
-  end
-
-  def test_read_and_write_to_file_round_trip
-    old_data = nil
-    NewRelic::DataSerialization.read_and_write_to_file do |data|
-      old_data = data
-      'a' * 30
-    end
-    NewRelic::DataSerialization.read_and_write_to_file do |data|
-      assert_equal('a'*30, data, "should be the same after serialization")
-    end
-  end
-
-  def test_should_send_data
-    NewRelic::DataSerialization.expects(:max_size).returns(20)
-    NewRelic::DataSerialization.read_and_write_to_file do
-      "a" * 30
-    end
-    assert(NewRelic::DataSerialization.should_send_data?, 'Should be over limit')
-  end
-
-  def test_should_send_data_disabled
-    NewRelic::Control.instance.expects(:disable_serialization?).returns(true)
-    assert(NewRelic::DataSerialization.should_send_data?, 'should send data when disabled')
-  end
-
-  def test_should_send_data_under_limit
-    NewRelic::DataSerialization.expects(:max_size).returns(50)
-    NewRelic::DataSerialization.read_and_write_to_file do
-      "a" * 5
-    end
-    assert(!NewRelic::DataSerialization.should_send_data?, 'Should be under the limit')
-  end
-end