newrelic_rpm 3.0.1 → 3.1.0.beta1

data/lib/new_relic/agent/stats_engine/transactions.rb

@@ -102,7 +102,7 @@ module Agent
       #
       def end_transaction
         stack = scope_stack
-              
+
         if stack && stack.empty?
           Thread::current[:newrelic_most_recent_transaction] = Thread::current[:newrelic_scope_name]
           Thread::current[:newrelic_scope_stack] = nil

data/lib/new_relic/agent/worker_loop.rb

@@ -25,7 +25,7 @@ module NewRelic
       # that runs this worker loop.  This will run the task immediately.
       def run(period=nil, &block)
         @period = period if period
-        @next_invocation_time = (Time.now + period)
+        @next_invocation_time = (Time.now + @period)
         @task = block
         while keep_running do
           now = Time.now

data/lib/new_relic/collection_helper.rb

@@ -32,10 +32,8 @@ module NewRelic
     if backtrace
       # this is for 1.9.1, where strings no longer have Enumerable
       backtrace = backtrace.split("\n") if String === backtrace
-      # strip newrelic from the trace
       backtrace = backtrace.reject {|line| line =~ /new_?relic/ }
       # rename methods back to their original state
-      # GJV - 4/6/10 - adding .to_s call since we were seeing line as a Fixnum in some cases
       backtrace = backtrace.collect {|line| line.to_s.gsub(/_without_(newrelic|trace)/, "")}
     end
     backtrace

data/lib/new_relic/control/class_methods.rb

@@ -6,26 +6,39 @@ module NewRelic
         @instance ||= new_instance
       end
 
+      def local_env
+        @local_env ||= NewRelic::LocalEnvironment.new
+      end
+
       # Create the concrete class for environment specific behavior:
       def new_instance
-        @local_env = NewRelic::LocalEnvironment.new
-        if @local_env.framework == :test
-          config = File.expand_path("../../../../test/config/newrelic.yml", __FILE__)
-          require "config/test_control"
-          NewRelic::Control::Frameworks::Test.new @local_env, config
+        if local_env.framework == :test
+          load_test_framework
         else
-          begin
-            require "new_relic/control/frameworks/#{@local_env.framework}.rb"
-          rescue LoadError
-          end
-          klass = NewRelic::Control::Frameworks.const_get(@local_env.framework.to_s.capitalize)
-          klass.new @local_env
+          load_framework_class(local_env.framework).new(local_env)
+        end
+      end
+
+      # nb this does not 'load test' the framework, it loads the 'test framework'
+      def load_test_framework
+        config = File.expand_path(File.join('..','..','..','..', "test","config","newrelic.yml"), __FILE__)
+        require "config/test_control"
+        NewRelic::Control::Frameworks::Test.new(local_env, config)
+      end
+
+      def load_framework_class(framework)
+        begin
+          require "new_relic/control/frameworks/#{framework}"
+        rescue LoadError
+          # maybe it is already loaded by some external system
+          # i.e. rpm_contrib or user extensions?
         end
+        NewRelic::Control::Frameworks.const_get(framework.to_s.capitalize)
       end
 
       # The root directory for the plugin or gem
       def newrelic_root
-        File.expand_path("../../../..", __FILE__)
+        File.expand_path(File.join("..", "..", "..", ".."), __FILE__)
       end
     end
     extend ClassMethods

data/lib/new_relic/control/logging_methods.rb

@@ -29,27 +29,40 @@ module NewRelic
         @settings && agent_enabled?
       end
 
-      # Control subclasses may override this, but it can be called multiple times.
-      def setup_log
-        @log_file = "#{log_path}/#{log_file_name}"
-        @log = Logger.new(@log_file) rescue nil
-
-        # change the format just for our logger
+      # set the log level as specified in the config file
+      def set_log_level!(logger)
+        case fetch("log_level","info").downcase
+          when "debug" then logger.level = Logger::DEBUG
+          when "info" then logger.level = Logger::INFO
+          when "warn" then logger.level = Logger::WARN
+          when "error" then logger.level = Logger::ERROR
+          when "fatal" then logger.level = Logger::FATAL
+          else logger.level = Logger::INFO
+        end
+        logger
+      end
 
-        def log.format_message(severity, timestamp, progname, msg)
+      # change the format just for our logger
+      def set_log_format!(logger)
+        def logger.format_message(severity, timestamp, progname, msg)
           "[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{Socket.gethostname} (#{$$})] #{severity} : #{msg}\n"
         end
+        logger
+      end
 
-        # set the log level as specified in the config file
-
-        case fetch("log_level","info").downcase
-          when "debug" then log.level = Logger::DEBUG
-          when "info" then log.level = Logger::INFO
-          when "warn" then log.level = Logger::WARN
-          when "error" then log.level = Logger::ERROR
-          when "fatal" then log.level = Logger::FATAL
-        else log.level = Logger::INFO
+      # Create the logger using the configuration variables
+      #
+      # Control subclasses may override this, but it can be called multiple times.
+      def setup_log
+        @log_file = "#{log_path}/#{log_file_name}"
+        @log = Logger.new(@log_file) rescue nil
+        if @log
+          set_log_format!(@log)
+          set_log_level!(@log)
         end
+        # note this is not the variable from above - it is the `log`
+        # method, which returns a default logger if none is setup
+        # above
         log
       end
 
@@ -58,7 +71,7 @@ module NewRelic
       end
 
       def log_path
-        return if @log_path
+        return @log_path if @log_path
         @log_path = File.expand_path(fetch('log_file_path', 'log/'))
         if !File.directory?(@log_path) && ! (Dir.mkdir(@log_path) rescue nil)
           log!("Error creating New Relic log directory '#{@log_path}'", :error)

data/lib/new_relic/data_serialization.rb

@@ -0,0 +1,81 @@
+require 'fileutils'
+module NewRelic
+  class DataSerialization
+    module ClassMethods
+      def should_send_data?
+        # TODO get configuration from main control
+        (File.size(file_path) >= max_size)
+      end
+
+      def load_from_file
+        create_file_if_needed
+        with_locked_store('r+') do |f|
+          get_data_from_file(f)
+        end
+      rescue(EOFError) => e
+        nil
+      end
+
+      def dump_to_file
+        create_file_if_needed
+        with_locked_store('r+') do |f|
+          result = (yield get_data_from_file(f))
+          f.rewind
+          f.write(dump(result))
+        end
+      end
+
+      private
+
+      def with_locked_store(mode)
+        File.open(file_path, mode) do |f|
+          f.flock(File::LOCK_EX)
+          begin
+            yield(f)
+          ensure
+            f.flock(File::LOCK_UN)
+          end
+        end
+      rescue Exception => e
+        puts e.inspect
+      end
+
+      def get_data_from_file(f)
+        data = f.read
+        result = load(data)
+        f.truncate(0)
+        result
+      end
+      
+      def max_size
+        100_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/local_environment.rb

@@ -247,7 +247,7 @@ module NewRelic
 
     def check_for_torquebox
       return unless defined?(::JRuby) &&
-        ( Java::OrgTorqueboxRailsWebDeployers::RailsRackDeployer rescue nil)
+         ( org.torquebox::TorqueBox rescue nil)
       @dispatcher = :torquebox
     end
 

data/lib/new_relic/metric_data.rb

@@ -17,9 +17,7 @@ module NewRelic
     def original_spec
       @original_spec || @metric_spec
     end
-    def metric_spec
-      @metric_spec
-    end
+
     def metric_spec= new_spec
       @original_spec = @metric_spec if @metric_spec
       @metric_spec = new_spec
@@ -35,8 +33,14 @@ module NewRelic
     end
 
     def to_s
-      "#{metric_spec.name}(#{metric_spec.scope}): #{stats}" if metric_spec
-      "#{metric_id}: #{stats}" if metric_spec.nil?
+      if metric_spec
+        "#{metric_spec.name}(#{metric_spec.scope}): #{stats}"
+      else
+        "#{metric_id}: #{stats}"
+      end
+    end
+    def inspect
+      "#<MetricData metric_spec:#{metric_spec.inspect}, stats:#{stats.inspect}, metric_id:#{metric_id.inspect}>"
     end
   end
 end

data/lib/new_relic/metric_spec.rb

@@ -26,7 +26,7 @@ class NewRelic::MetricSpec
     self.class == o.class &&
     name.eql?(o.name) &&
     # coerce scope to a string and compare
-     (scope || '') == (o.scope || '')
+     scope.to_s == o.scope.to_s
   end
 
   def hash
@@ -37,6 +37,7 @@ class NewRelic::MetricSpec
   # return a new metric spec if the given regex
   # matches the name or scope.
   def sub(pattern, replacement, apply_to_scope = true)
+    NewRelic::Control.instance.log.warn("The sub method on metric specs is deprecated") rescue nil
     return nil if name !~ pattern &&
      (!apply_to_scope || scope.nil? || scope !~ pattern)
     new_name = name.sub(pattern, replacement)[0...MAX_LENGTH]
@@ -51,9 +52,14 @@ class NewRelic::MetricSpec
   end
 
   def to_s
+    return name if scope.empty?
     "#{name}:#{scope}"
   end
 
+  def inspect
+    "#<NewRelic::MetricSpec '#{name}':'#{scope}'>"
+  end
+
   def to_json(*a)
     {'name' => name,
     'scope' => scope}.to_json(*a)

data/lib/new_relic/rack/browser_monitoring.rb

@@ -9,12 +9,6 @@ module NewRelic::Rack
 
     # method required by Rack interface
     def call(env)
-      
-      # clear out the thread locals we use in case this is a static request
-      Thread.current[:newrelic_most_recent_transaction] = nil
-      Thread.current[:newrelic_start_time] = Time.now
-      Thread.current[:newrelic_queue_time] = 0
-      
       result = @app.call(env)   # [status, headers, response]
 
       if (NewRelic::Agent.browser_timing_header != "") && should_instrument?(result[0], result[1])
@@ -36,7 +30,7 @@ module NewRelic::Rack
 
     def autoinstrument_source(response, headers)
       source = nil
-      response.each {|fragment| (source) ? (source << fragment) : (source = fragment)}
+      response.each {|fragment| (source) ? (source << f) : (source = fragment)}
 
       body_start = source.index("<body")
       body_close = source.rindex("</body>")

data/lib/new_relic/stats.rb

@@ -353,6 +353,10 @@ module NewRelic
       @call_count += value
     end
 
+    def inspect
+      "#<NewRelic::MethodTraceStats #{summary} >"
+    end
+
   end
 
   class ScopedMethodTraceStats < MethodTraceStats

data/lib/new_relic/transaction_analysis.rb

@@ -1,108 +1,65 @@
+require 'new_relic/transaction_analysis/segment_summary'
 # Add these methods to TransactionSample that enable performance analysis in the user interface.
 module NewRelic
-module TransactionAnalysis
-  def database_time
-    time_percentage(/^Database\/.*/)
-  end
-
-  def render_time
-    time_percentage(/^View\/.*/)
-  end
-
-  # summarizes performance data for all calls to segments
-  # with the same metric_name
-  class SegmentSummary
-    attr_accessor :metric_name, :total_time, :exclusive_time, :call_count
-    def initialize(metric_name, sample)
-      @metric_name = metric_name
-      @total_time, @exclusive_time, @call_count = 0,0,0
-      @sample = sample
-    end
-
-    def <<(segment)
-      if metric_name != segment.metric_name
-        raise ArgumentError, "Metric Name Mismatch: #{segment.metric_name} != #{metric_name}"
-      end
-
-      @total_time += segment.duration
-      @exclusive_time += segment.exclusive_duration
-      @call_count += 1
+  module TransactionAnalysis
+    def database_time
+      time_percentage(/^Database\/.*/)
     end
 
-    def average_time
-      @total_time / @call_count
+    def render_time
+      time_percentage(/^View\/.*/)
     end
 
-    def average_exclusive_time
-      @exclusive_time / @call_count
-    end
-
-    def exclusive_time_percentage
-      return 0 unless @exclusive_time && @sample.duration && @sample.duration > 0
-      @exclusive_time / @sample.duration
-    end
+    # return the data that breaks down the performance of the transaction
+    # as an array of SegmentSummary objects.  If a limit is specified, then
+    # limit the data set to the top n
+    def breakdown_data(limit = nil)
+      metric_hash = {}
+      each_segment do |segment|
+        unless segment == root_segment
+          metric_name = segment.metric_name
+          metric_hash[metric_name] ||= SegmentSummary.new(metric_name, self)
+          metric_hash[metric_name] << segment
+        end
+      end
 
-    def total_time_percentage
-      return 0 unless @total_time && @sample.duration && @sample.duration > 0
-      @total_time / @sample.duration
-    end
+      data = metric_hash.values
 
-    def ui_name
-      return @metric_name if @metric_name == 'Remainder'
-      NewRelic::MetricParser::MetricParser.parse(@metric_name).developer_name
-    end
-  end
-
-  # return the data that breaks down the performance of the transaction
-  # as an array of SegmentSummary objects.  If a limit is specified, then
-  # limit the data set to the top n
-  def breakdown_data(limit = nil)
-    metric_hash = {}
-    each_segment do |segment|
-      unless segment == root_segment
-        metric_name = segment.metric_name
-        metric_hash[metric_name] ||= SegmentSummary.new(metric_name, self)
-        metric_hash[metric_name] << segment
+      data.sort! do |x,y|
+        y.exclusive_time <=> x.exclusive_time
       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
 
-    if limit && data.length > limit
-      data = data[0..limit - 1]
-    end
+      # add one last segment for the remaining time if any
+      remainder = duration
+      data.each do |segment|
+        remainder -= segment.exclusive_time
+      end
 
-    # add one last segment for the remaining time if any
-    remainder = duration
-    data.each do |segment|
-      remainder -= segment.exclusive_time
-    end
+      if (remainder*1000).round > 0
+        remainder_summary = SegmentSummary.new('Remainder', self)
+        remainder_summary.total_time = remainder_summary.exclusive_time = remainder
+        remainder_summary.call_count = 1
+        data << remainder_summary
+      end
 
-    if (remainder*1000).round > 0
-      remainder_summary = SegmentSummary.new('Remainder', self)
-      remainder_summary.total_time = remainder_summary.exclusive_time = remainder
-      remainder_summary.call_count = 1
-      data << remainder_summary
+      data
     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(show_non_sql_segments = true)
-    segments = []
-    each_segment do |segment|
-      segments << segment if segment[:sql] || segment[:sql_obfuscated] || (show_non_sql_segments && segment[:key])
+    # 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(show_non_sql_segments = true)
+      segments = []
+      each_segment do |segment|
+        segments << segment if segment[:sql] || segment[:sql_obfuscated] || (show_non_sql_segments && segment[:key])
+      end
+      segments
     end
-    segments
-  end
 
-  private
+    private
     def time_percentage(regex)
       total = 0
       each_segment do |segment|