newrelic_rpm 2.9.9 → 2.10.3

data/lib/new_relic/transaction_analysis.rb

@@ -1,5 +1,6 @@
 # Add these methods to TransactionSample that enable performance analysis in the user interface.
-module NewRelic::TransactionAnalysis
+module NewRelic
+module TransactionAnalysis
   def database_time
     time_percentage(/^Database\/.*/)
   end
@@ -118,4 +119,6 @@ module NewRelic::TransactionAnalysis
       # percent value rounded to two digits:
       return (100 * fraction).round / 100.0
     end
-end
+  end
+end
+

data/lib/new_relic/transaction_sample.rb

@@ -16,17 +16,17 @@ module NewRelic
       ].freeze
   
   class TransactionSample
+    EMPTY_ARRAY = [].freeze
     
     @@start_time = Time.now
 
     include TransactionAnalysis
     class Segment
       
-      class << self
-        @@empty_array = []
-      end
       
       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
@@ -34,7 +34,7 @@ module NewRelic
       
       def initialize(timestamp, metric_name, segment_id)
         @entry_timestamp = timestamp
-        @metric_name = metric_name
+        @metric_name = metric_name || '<unknown>'
         @segment_id = segment_id || object_id
       end
       
@@ -66,18 +66,30 @@ module NewRelic
         map.to_json
       end
       
-      def self.from_json(json)
+      def self.from_json(json, id_generator)
         json = ActiveSupport::JSON.decode(json) if json.is_a?(String)
-        segment = Segment.new(json["entry_timestamp"].to_f, json["metric_name"], json["segment_id"])
-        segment.end_trace json["exit_timestamp"].to_f
-        params = json["params"]
+        if json.is_a?(Array)
+          entry_timestamp = json[0].to_f / 1000
+          exit_timestamp = json[1].to_f / 1000
+          metric_name = json[2]
+          params = json[3]
+          called_segments = json[4]
+        else
+          entry_timestamp = json["entry_timestamp"].to_f
+          exit_timestamp = json["exit_timestamp"].to_f
+          metric_name =  json["metric_name"]       
+          params = json["params"]
+          
+          called_segments = json["called_segments"]
+        end
+        segment = Segment.new(entry_timestamp, metric_name, id_generator.next_id)
+        segment.end_trace exit_timestamp
         if params
           segment.send :params=, HashWithIndifferentAccess.new(params)
         end
-        called_segments = json["called_segments"]
         if called_segments
           called_segments.each do |child|
-            segment.add_called_segment(self.from_json(child))
+            segment.add_called_segment(self.from_json(child, id_generator))
           end
         end
         segment
@@ -86,45 +98,42 @@ module NewRelic
       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.times {tab << "  "}
-        
+        tab = "  " * depth 
         s = tab.clone
-        s << ">> #{metric_name}: #{(@entry_timestamp*1000).round}\n"
+        s << ">> #{'%3i ms' % (@entry_timestamp*1000)} [#{self.class.name.split("::").last}] #{metric_name} \n"
         unless params.empty?
-          s << "#{tab}#{tab}{\n"
           params.each do |k,v|
-            s << "#{tab}#{tab}#{k}: #{v}\n"
+            s << "#{tab}    -#{'%-16s' % k}: #{v.to_s[0..80]}\n"
           end
-          s << "#{tab}#{tab}}\n"
         end
         called_segments.each do |cs|
           s << cs.to_debug_str(depth + 1)
         end
-        s << tab
-        s << "<< #{metric_name}: #{@exit_timestamp ? (@exit_timestamp*1000).round : 'n/a'}\n"
-        s
+        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 || @@empty_array
-      end
-      
-      def freeze
-        params.freeze
-        if @called_segments
-          @called_segments.each do |s|
-            s.freeze
-          end
-        end
-        super
+        @called_segments || EMPTY_ARRAY
       end
       
       # return the total duration of this segment
       def duration
-        @exit_timestamp - @entry_timestamp
+        (@exit_timestamp - @entry_timestamp).to_f
       end
       
       # return the duration of this segment without 
@@ -139,7 +148,28 @@ module NewRelic
         end
         d
       end
-      
+      def count_segments
+        count = 1
+        @called_segments.each { | seg | count  += seg.count_segments } if @called_segments
+        count
+      end
+      # Walk through the tree and truncate the segments
+      def truncate(max)
+        return max unless @called_segments
+        i = 0
+        @called_segments.each do | segment |
+          max = segment.truncate(max)
+          max -= 1
+          if max <= 0
+            @called_segments = @called_segments[0..i]
+            break
+          else
+            i += 1
+          end
+        end
+        max
+      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
@@ -242,7 +272,11 @@ module NewRelic
           @params = p
         end
     end
-    
+
+    class FakeSegment < Segment
+      public :parent_segment=
+    end
+
     class SummarySegment < Segment
       
       
@@ -319,8 +353,8 @@ module NewRelic
       end
       
     end
-        
 
+    attr_accessor :profile
     attr_reader :root_segment
     attr_reader :params
     attr_reader :sample_id
@@ -333,12 +367,29 @@ module NewRelic
       @params[:request_params] = {}
     end
 
+    def count_segments
+      @root_segment.count_segments - 1    # don't count the root segment
+    end
+    
+    def truncate(max)
+      original_count = count_segments
+      
+      return if original_count <= max
+      
+      @root_segment.truncate(max-1)
+      
+      if params[:segment_count].nil?
+        params[:segment_count] = original_count
+      end
+    end
+    
     # offset from start of app
     def timestamp
       @start_time - @@start_time.to_f
     end
     
-    def to_json(options = {})
+    # Used in the server only
+    def to_json(options = {}) #:nodoc:
       map = {:sample_id => @sample_id,
         :start_time => @start_time,
         :root_segment => @root_segment}
@@ -348,16 +399,33 @@ module NewRelic
       map.to_json
     end
     
-    def self.from_json(json)
+    # Used in the Server only
+    def self.from_json(json) #:nodoc:
       json = ActiveSupport::JSON.decode(json) if json.is_a?(String)
-      sample = TransactionSample.new(json["start_time"].to_f, json["sample_id"].to_i)
-      params = json["params"]
+      
+      if json.is_a?(Array)
+        start_time = json[0].to_f / 1000
+        custom_params = HashWithIndifferentAccess.new(json[2])
+        params = {:request_params => HashWithIndifferentAccess.new(json[1]), 
+              :custom_params => custom_params}
+        cpu_time = custom_params.delete(:cpu_time)
+        sample_id = nil
+        params[:cpu_time] = cpu_time.to_f / 1000 if cpu_time
+        root = json[3]
+      else
+        start_time = json["start_time"].to_f 
+        sample_id = json["sample_id"].to_i
+        params = json["params"] 
+        root = json["root_segment"]
+      end
+      
+      sample = TransactionSample.new(start_time, sample_id)
+      
       if params
         sample.send :params=, HashWithIndifferentAccess.new(params)
       end
-      root = json["root_segment"]
       if root
-        sample.send :root_segment=, Segment.from_json(root)
+        sample.send :root_segment=, Segment.from_json(root, IDGenerator.new)
       end
       sample
     end
@@ -370,17 +438,11 @@ module NewRelic
       @root_segment.path_string
     end
     
-    def create_segment (relative_timestamp, metric_name, segment_id = nil)
+    def create_segment(relative_timestamp, metric_name, segment_id = nil)
       raise TypeError.new("Frozen Transaction Sample") if frozen?
       NewRelic::TransactionSample::Segment.new(relative_timestamp, metric_name, segment_id)    
     end
     
-    def freeze
-      @root_segment.freeze
-      params.freeze
-      super
-    end
-    
     def duration
       root_segment.duration
     end
@@ -389,6 +451,10 @@ module NewRelic
       @root_segment.each_segment(&block)
     end
     
+    def to_s_compact
+      @root_segment.to_s_compact
+    end
+    
     def find_segment(id)
       @root_segment.find_segment(id)
     end
@@ -402,9 +468,12 @@ module NewRelic
         next if k == :path
         s << "  #{k}: " <<
         case v
-          when Enumerable; v.map(&:to_s).sort.join("; ")
+          when Enumerable then v.map(&:to_s).sort.join("; ")
+          when String then v
+          when Float then '%6.3s' % v
+          when nil then ''
         else
-          v
+          raise "unexpected value type for #{k}: '#{v}' (#{v.class})"
         end << "\n"
       end
       s << "  }\n\n"
@@ -424,8 +493,9 @@ module NewRelic
       params.each {|k,v| sample.params[k] = v}
         
       delta = build_segment_with_omissions(sample, 0.0, @root_segment, sample.root_segment, regex)
-      sample.root_segment.end_trace(@root_segment.exit_timestamp - delta) 
-      sample.freeze
+      sample.root_segment.end_trace(@root_segment.exit_timestamp - delta)
+      sample.profile = self.profile
+      sample
     end
     
     # return a new transaction sample that can be sent to the RPM service.
@@ -446,7 +516,7 @@ module NewRelic
       end
       
       sample.root_segment.end_trace(@root_segment.exit_timestamp) 
-      sample.freeze
+      sample
     end
     
     def analyze
@@ -501,7 +571,6 @@ module NewRelic
     
     def summarize_segments(like_segments)
       if like_segments.length > COLLAPSE_SEGMENTS_THRESHOLD
-        puts "#{like_segments.first.path_string} #{like_segments.length}"
         [CompositeSegment.new(like_segments)]
       else
         like_segments
@@ -571,5 +640,15 @@ module NewRelic
         target_called_segment.end_trace(source_called_segment.exit_timestamp)
       end
     end
+    
+    # Generates segment ids for json transaction segments
+    class IDGenerator
+      def initialize
+        @next_id = 0        
+      end
+      def next_id
+        @next_id += 1
+      end
+    end
   end
 end

data/lib/new_relic/version.rb

@@ -2,46 +2,53 @@
 module NewRelic
   module VERSION #:nodoc:
     MAJOR = 2
-    MINOR = 9
-    TINY  = 9
-    STRING = [MAJOR, MINOR, TINY].join('.')
+    MINOR = 10
+    TINY  = 3
+    EXPERIMENTAL = nil 
+    STRING = [MAJOR, MINOR, TINY, EXPERIMENTAL].compact.join('.')
   end
   
   # Helper class for managing version comparisons 
   class VersionNumber
-    attr_reader :major_version, :minor_version, :tiny_version
+    attr_reader :parts
     include Comparable
     def initialize(version_string)
       version_string ||= '1.0.0'
       @parts = version_string.split('.').map{|n| n.to_i }
-      @major_version, @minor_version, @tiny_version = (version_string.split('.') + %w[0 0 0]).map(&:to_i)
     end
     def major_version; @parts[0]; end
     def minor_version; @parts[1]; end
     def tiny_version; @parts[2]; end
     
     def <=>(other)
-      other = VersionNumber.new(other) if other.is_a?(String)
-      self.scalar_value <=> other.scalar_value 
-    end
-    
-    def eql?(other)
-      return self.scalar_value == other.scalar_value rescue nil
+      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 scalar_value
-      if !@scalar_value
-        bits = 24
-        @scalar_value = @parts.inject(0) do | value, part |
-          bits -= 6
-          value + (part << bits)
-        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 -1
+        when b.nil? then 1
+        when a == b
+          compare(parts1[1..-1], parts2[1..-1])
+        else
+          a <=> b
       end
-      @scalar_value
     end
-    alias hash scalar_value
   end
 end

data/lib/new_relic_api.rb

@@ -6,10 +6,10 @@
 #
 # Authentication is handled using your agent license key or HTTP Basic Authentication.  To authenticate
 # using your license key your newrelic.yml configuration file must be in your application config directory
-# and contain your license key.  The New Relic account associated with the license key must allow api access.  
+# and contain your license key.  The New Relic account associated with the license key must allow api access.
 # Log into RPM, click Account at the top of the page and check the "Make my account data accessible" checkbox.
 #
-# Basic authentication uses your site credentials to authenticate.  
+# Basic authentication uses your site credentials to authenticate.
 #
 #   # To authenticate using basic authentication, make this call with your username and password:
 #   NewRelicApi.authenticate('user@example.com', 'test')
@@ -20,7 +20,7 @@
 #
 #   # Fetching the list of applications for an account
 #   NewRelicApi::Account.find(:first).applications
-#  
+#
 #   # Fetching the health values for all account applications
 #   NewRelicApi::Account.application_health
 #
@@ -32,9 +32,9 @@
 #
 
 module NewRelicApi
-  
+
   # This mixin defines ActiveRecord style associations (like has_many) for ActiveResource objects.
-  # ActiveResource objects using this mixin must define the method 'query_params'. 
+  # ActiveResource objects using this mixin must define the method 'query_params'.
   module ActiveResourceAssociations #:nodoc:
     class << self
       protected
@@ -46,10 +46,10 @@ module NewRelicApi
               define_method association do |*args|
                 val = attributes[association.to_s] # if we've already fetched the relationship in the initial fetch, return it
                 return val if val
-                
+
                 options = args.extract_options!
                 type = args.first || :all
-                
+
                 begin
                   # look for the class definition within the current class
                   clazz = ( self.class.name + '::' + association.to_s.camelize.singularize).constantize
@@ -60,38 +60,39 @@ module NewRelicApi
                 params = (options[:params] || {}).update(self.query_params)
                 options[:params] = params
                 clazz.find(type, options)
-                
+
                 #clazz.find(type, :params => options.update(self.query_params))
               end
             end
-          end          
+          end
         end
       end
     end
-    
+
   end
   class << self
     attr_accessor :email, :password, :license_key, :ssl, :host, :port
-    
+
     # Sets up basic authentication credentials for all the resources.  This is not necessary if you are
     # using agent license key authentication.
     def authenticate(email, password)
       @password = password
       @email    = email
     end
-    
+
     # Resets the base path of all resources.  This should be called when overridding the newrelic.yml settings
     # using the ssl, host or port accessors.
     def reset!
       @classes.each {|klass| klass.reset!} if @classes
       NewRelicApi::Account.site_url
     end
-    
-    
+
+
     def track_resource(klass) #:nodoc:
       (@classes ||= []) << klass
     end
   end
+
   class BaseResource < ActiveResource::Base #:nodoc:
     include ActiveResourceAssociations
 
@@ -99,25 +100,25 @@ module NewRelicApi
       def inherited(klass) #:nodoc:
         NewRelicApi.track_resource(klass)
       end
-      
+
       def headers
         h = {'x-license-key' => NewRelicApi.license_key || NewRelic::Control.instance['license_key']}
         h['Authorization'] = 'Basic ' + ["#{NewRelicApi.email}:#{NewRelicApi.password}"].pack('m').delete("\r\n") if NewRelicApi.email
         h
       end
-      
+
       def site_url
         host = NewRelicApi.host || NewRelic::Control.instance.api_server.name
         port = NewRelicApi.port || NewRelic::Control.instance.api_server.port
         "#{port == 443 ? 'https' : 'http'}://#{host}:#{port}"
       end
-      
+
       def reset!
         self.site = self.site_url
       end
-      
+
       protected
-      
+
       def fix_fields(*fields)
         fields.to_a.each do |field|
           define_method field do
@@ -125,22 +126,22 @@ module NewRelicApi
           end
         end
       end
-      
+
       def fix_integer_fields(*fields)
         fix_fields(*fields) { |sup| sup.to_i }
       end
-      
+
       def fix_float_fields(*fields)
         fix_fields(*fields) { |sup| sup.to_f }
       end
-      
+
     end
     self.site = self.site_url
   end
   ACCOUNT_RESOURCE_PATH = '/accounts/:account_id/' #:nodoc:
   ACCOUNT_AGENT_RESOURCE_PATH = ACCOUNT_RESOURCE_PATH + 'agents/:agent_id/' #:nodoc:
   ACCOUNT_APPLICATION_RESOURCE_PATH = ACCOUNT_RESOURCE_PATH + 'applications/:application_id/' #:nodoc:
-  
+
   module AccountResource #:nodoc:
     def account_id
       prefix_options[:account_id]
@@ -148,45 +149,44 @@ module NewRelicApi
     def account_query_params(extra_params = {})
       {:account_id => account_id}.merge(extra_params)
     end
-    
+
     def query_params#:nodoc:
       account_query_params
     end
-    
   end
-  
+
   module AgentResource #:nodoc:
     include ActiveResourceAssociations
   end
-    
+
   # An application has many:
   # +agents+:: the agent instances associated with this app
   # +threshold_values+:: the health indicators for this application.
   class Application < BaseResource
     include AccountResource
     include AgentResource
-    
+
     has_many :agents, :threshold_values
-    
+
     self.prefix = ACCOUNT_RESOURCE_PATH
-    
+
     def query_params#:nodoc:
       account_query_params(:application_id => id)
     end
-    
+
     class Agent < BaseResource
       include AccountResource
       include AgentResource
-      
+
       self.prefix = ACCOUNT_APPLICATION_RESOURCE_PATH
-      
+
       def query_params#:nodoc:
         super.merge(:application_id => cluster_agent_id)
       end
     end
-    
+
   end
-  
+
   # A threshold value represents a single health indicator for an application such as CPU, memory or response time.
   #
   # ==Fields
@@ -196,10 +196,10 @@ module NewRelicApi
   class ThresholdValue < BaseResource
     self.prefix = ACCOUNT_APPLICATION_RESOURCE_PATH
     #      attr_reader :name, :begin_time, :metric_value, :threshold_value
-    
+
     fix_integer_fields :threshold_value
     fix_float_fields :metric_value
-    
+
     # Returns the color value for this threshold (Gray, Green, Yellow or Red).
     def color_value
       case threshold_value
@@ -209,17 +209,17 @@ module NewRelicApi
       else 'Gray'
       end
     end
-    
+
     def to_s #:nodoc:
       "#{name}: #{color_value} (#{formatted_metric_value})"
     end
   end
-  
+
   # An account contains your basic account information.
   #
   # Accounts have many
   # +applications+:: the applications contained within the account
-  # 
+  #
   # Find Accounts
   #
   #   NewRelicApi::Account.find(:all) # find all accounts for the current user.
@@ -227,18 +227,33 @@ module NewRelicApi
   #
   class Account < BaseResource
     has_many :applications
-    
+    has_many :account_views
+
     def query_params #:nodoc:
       {:account_id => id}
     end
-    
+
     # Returns an account including all of its applications and the threshold values for each application.
     def self.application_health(type = :first)
       find(type, :params => {:include => :application_health})
     end
+
+    class AccountView < BaseResource
+      self.prefix = ACCOUNT_RESOURCE_PATH
+
+      def query_params(extra_params = {}) #:nodoc:
+        {:account_id => account_id}.merge(extra_params)
+      end
+
+      def user
+        @attributes['user']
+      end
+    end
+
+    class AccountUsage < BaseResource
+    end
   end
-  
-  
+
   # This model is used to mark production deployments in RPM
   # Only create is supported.
   # ==Examples
@@ -247,10 +262,15 @@ module NewRelicApi
   #
   class Deployment < BaseResource
   end
-  
-  class User < BaseResource
-  end
+
   class Subscription < BaseResource
+    def query_params(extra_params = {}) #:nodoc:
+      {:account_id => account_id}.merge(extra_params)
+    end
   end
+
+  class User < BaseResource
+  end
+
 end