factorylabs-newrelic_rpm 2.10.2.2

data/lib/new_relic/merbtasks.rb

@@ -0,0 +1,6 @@
+namespace :newrelic do
+  desc "Install the developer mode newrelic.yml file"
+  task :default do
+    load File.expand_path(File.join(__FILE__,"..","..","install.rb"))
+  end
+end

data/lib/new_relic/metric_data.rb

@@ -0,0 +1,42 @@
+module NewRelic
+  class MetricData
+    attr_accessor :metric_spec
+    attr_accessor :metric_id
+    attr_accessor :stats
+    
+    def initialize(metric_spec, stats, metric_id)
+      @metric_spec = metric_spec
+      self.stats = stats
+      self.metric_id = metric_id
+    end
+    
+    def eql?(o)
+     (metric_spec.eql? o.metric_spec) && (stats.eql? o.stats)
+    end
+
+    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
+    end
+    
+    def hash
+      metric_spec.hash ^ stats.hash
+    end
+    
+    # Serialize with all attributes, but if the metric id is not nil, then don't send the metric spec
+    def to_json(*a)
+       %Q[{"metric_spec":#{metric_id ? 'null' : metric_spec.to_json},"stats":{"total_exclusive_time":#{stats.total_exclusive_time},"min_call_time":#{stats.min_call_time},"call_count":#{stats.call_count},"sum_of_squares":#{stats.sum_of_squares},"total_call_time":#{stats.total_call_time},"max_call_time":#{stats.max_call_time}},"metric_id":#{metric_id ? metric_id : 'null'}}]
+    end
+    
+    def to_s
+      "#{metric_spec.name}(#{metric_spec.scope}): #{stats}" if metric_spec
+      "#{metric_id}: #{stats}" if metric_spec.nil?
+    end
+  end
+end

data/lib/new_relic/metric_parser.rb

@@ -0,0 +1,124 @@
+module NewRelic
+  # Metric parsing logic mixin.  Given a metric name (attribute called "name"), provide a set of accessors
+  # that enable inspection of the metric.  A metric has 2 or more segments, each separated
+  # by the '/' character.  The metric's category is specified by its first segment. Following
+  # are the set of categories currently supported by NewRelic's default metric set:
+  #
+  # * Controller
+  # * ActiveRecord
+  # * Rails
+  # * WebService
+  # * View
+  # * Database
+  # * Custom
+  #
+  # Based on the category of the metric, specific parsing logic is defined in the source files
+  # countained in the "metric_parsers" sub directory local to this file.
+  #
+  
+  class MetricParser
+    
+    SEPARATOR = '/' unless defined? SEPARATOR
+    attr_reader :name
+    
+    # Load in the parsers classes in the plugin:
+    Dir[File.join(File.dirname(__FILE__), "metric_parser", "*.rb")].each { | file | require file }
+    
+    # return a string that is parsable via the Metric parser APIs
+    def self.for_metric_named(s)
+      category = (s =~ /^([^\/]*)/) && $1
+      parser_class = self
+      if category
+        parser_class = NewRelic::MetricParser.const_get(category) if (NewRelic::MetricParser.const_defined?(category) rescue nil)
+      end
+      parser_class.new s
+    end
+
+    def self.parse(s)
+      for_metric_named(s)
+    end
+    
+    def method_missing(method_name, *args)
+      return false if method_name.to_s =~ /^is_.*\?/
+      super
+    end
+    # The short name for the metric is defined as all of the segments
+    # of the metric name except for its first (its domain).
+    def short_name
+      if segments.empty?
+        ''
+      elsif segments.length == 1
+        segments[0]
+      else
+        segments[1..-1].join(SEPARATOR)
+      end
+    end
+    
+    def pie_chart_label
+      developer_name
+    end
+    
+    def developer_name
+      short_name
+    end
+    
+    def tooltip_name
+      short_name
+    end
+    
+    def apdex_metric_path
+      "Apdex/#{segments[1..-1].join('/')}"
+    end
+    
+    # A short name for legends in the graphs
+    def legend_name
+      short_name
+    end
+    
+    # Return the name of another metric if the current
+    # metric is really add-on data for another metric.
+    def base_metric_name
+      nil
+    end
+    
+    def category
+      segments[0]
+    end
+    
+    def segments
+      return [] if !name
+      @segments ||= name.split(SEPARATOR).freeze
+    end
+    
+    # --
+    # These accessors are used to allow chart to use a specific segment  in the metric
+    # name for label construction as a zero-arg accessor
+    # ++
+    def segment_0; segments[0]; end
+    def segment_1; segments[1]; end
+    def segment_2; segments[2]; end
+    def segment_3; segments[3]; end
+    def segment_4; segments[4]; end
+    def last_segment; segments.last; end
+    
+    # This is the suffix used for call rate or throughput.  By default, it's cpm
+    # but things like controller actions will override to use something like 'rpm'
+    # for requests per minute
+    def call_rate_suffix
+    'cpm'
+    end
+    
+    def url
+    ''
+    end
+    
+    # returns a hash of params for url_for(), giving you a drilldown URL to an RPM page for this metric
+    # define in subclasses - TB 2009-12-18
+    # def drilldown_url(metric_id); end
+    
+    def initialize(name)
+      @name = name
+    end
+    
+  end  
+end

data/lib/new_relic/metric_parser/action_mailer.rb

@@ -0,0 +1,9 @@
+class NewRelic::MetricParser::ActionMailer < NewRelic::MetricParser
+  
+  def is_action_mailer?; true; end
+    
+  def short_name
+    "ActionMailer - #{segments[1]}"
+  end
+  
+end

data/lib/new_relic/metric_parser/active_merchant.rb

@@ -0,0 +1,26 @@
+class NewRelic::MetricParser::ActiveMerchant < NewRelic::MetricParser
+  
+  def is_active_merchant?; true; end
+  
+  def is_active_merchant_gateway?
+    segments[1] == 'gateway'
+  end
+  
+  def is_active_merchant_operation?
+    segments[1] == 'operation'
+  end
+  
+  def gateway_name
+    # ends in "Gateway" - trim that off
+    segments[2][0..-8].titleize
+  end
+  
+  def operation_name
+    segments[2]
+  end
+  
+  def short_name
+    segments[2]
+  end
+  
+end

data/lib/new_relic/metric_parser/active_record.rb

@@ -0,0 +1,25 @@
+class NewRelic::MetricParser::ActiveRecord < NewRelic::MetricParser
+  def is_active_record? ; true; end
+  
+  def model_class
+    return segments[1]
+  end
+  
+  def legend_name
+    if name == 'ActiveRecord/all'
+      'Database'
+    else
+      super
+    end
+  end
+  def tooltip_name
+    if name == 'ActiveRecord/all'
+      'all SQL execution'
+    else
+      super
+    end
+  end
+  def developer_name
+    "#{model_class}##{segments.last}"
+  end
+end

data/lib/new_relic/metric_parser/controller.rb

@@ -0,0 +1,54 @@
+class NewRelic::MetricParser::Controller < NewRelic::MetricParser
+
+  def is_controller?
+    true
+  end
+  
+  # If the controller name segments look like a file path, convert it to the controller
+  # class name.  If it begins with a capital letter, assume it's already a class name
+  def controller_name
+    path = segments[1..-2].join('/')
+    path < 'a' ? path : path.camelize+"Controller" 
+  end
+
+  def action_name
+    if segments[-1] =~ /^\(other\)$/
+      '(template only)'
+    else
+      segments[-1]
+    end
+  end
+  
+  def developer_name
+    "#{controller_name}##{action_name}"
+  end
+  
+  # return the cpu measuring equivalent.  It may be nil since this metric was not
+  # present in earlier versions of the agent.
+  def cpu_metric
+    Metric.lookup((["ControllerCPU"] + segments[1..-1]).join('/'), :create => false)
+  end
+  
+  def short_name
+    # standard controller actions
+    if segments.length > 1
+      url
+    else
+      'All Controller Actions'
+    end
+  end
+  
+  def url
+    '/' + segments[1..-1].join('/')
+  end
+  
+  # this is used to match transaction traces to controller actions.  
+  # TT's don't have a preceding slash :P
+  def tt_path
+    segments[1..-1].join('/')
+  end
+
+  def call_rate_suffix
+    'rpm'
+  end
+end

data/lib/new_relic/metric_parser/controller_cpu.rb

@@ -0,0 +1,38 @@
+class NewRelic::MetricParser::ControllerCPU < NewRelic::MetricParser
+  
+  def is_controller_cpu?; true; end
+  
+  def controller_name
+    segments[1..-2].join('/').camelize+"Controller"
+  end
+
+  def action_name
+    segments[-1]
+  end
+
+  def developer_name
+    "#{controller_name}##{action_name}"
+  end
+
+  def base_metric_name
+    "Controller/" + segments[1..-1].join('/')
+  end
+  
+  def short_name
+    # standard controller actions
+    if segments.length > 1
+      url
+    else
+      'All Controller Actions'
+    end
+  end
+  
+  def url
+    '/' + segments[1..-1].join('/')
+  end
+
+  def call_rate_suffix
+    'rpm'
+  end
+
+end

data/lib/new_relic/metric_parser/errors.rb

@@ -0,0 +1,6 @@
+class NewRelic::MetricParser::Errors < NewRelic::MetricParser
+  def is_error?; true; end
+  def short_name
+    segments[2..-1].join(NewRelic::MetricParser::SEPARATOR)
+  end
+end

data/lib/new_relic/metric_parser/external.rb

@@ -0,0 +1,50 @@
+class NewRelic::MetricParser::External < NewRelic::MetricParser
+  
+  def all?
+    host == 'all' || host == 'allWeb' || host == 'allOther'
+  end
+  def hosts_all?
+    library == 'all'
+  end
+  def host
+    segments[1]
+  end
+  def library
+    segments[2]
+  end
+  def operation
+    segments[3] && segments[3..-1].join("/")
+  end
+  def legend_name
+    case
+    when all?
+      "External Services"
+    when hosts_all?
+      "All #{host} calls"
+    else
+      developer_name
+    end
+  end
+  def tooltip_name
+    case
+    when all?
+      "calls to external systems"
+    when hosts_all?
+      "calls to #{host}"
+    else
+      "calls to #{developer_name}"
+    end
+  end
+  def developer_name
+    case 
+    when all?
+      'All External'
+    when hosts_all?
+      host
+    when operation
+      "#{library}[#{host}]: #{operation}"
+    else
+      "#{library}[#{host}]"
+    end
+  end
+end

data/lib/new_relic/metric_parser/mem_cache.rb

@@ -0,0 +1,12 @@
+class NewRelic::MetricParser::MemCache < NewRelic::MetricParser
+  def is_memcache?; true; end
+  
+  # for MemCache metrics, the short name is actually
+  # the full name
+  def short_name
+    name
+  end
+  def developer_name
+    "MemCache #{segments[1..-1].join '/'}"
+  end
+end

data/lib/new_relic/metric_parser/other_transaction.rb

@@ -0,0 +1,15 @@
+# OtherTransaction metrics must have at least three segments: /OtherTransaction/<task>/*
+
+class NewRelic::MetricParser::OtherTransaction < NewRelic::MetricParser
+  def task
+    segments[1]
+  end
+  
+  def developer_name
+    segments[2..-1].join(NewRelic::MetricParser::SEPARATOR)
+  end
+  
+  def drilldown_url(metric_id)
+    {:controller => '/v2/background_tasks', :action => 'index', :task => task, :anchor => "id=#{metric_id}"}
+  end
+end

data/lib/new_relic/metric_parser/view.rb

@@ -0,0 +1,61 @@
+class NewRelic::MetricParser::View < NewRelic::MetricParser
+  def is_view?; true; end
+
+  def is_render?
+    segments.last == "Rendering"
+  end
+  def is_compiler?
+    segments.last == "Compile"
+  end
+  def pie_chart_label
+    case segments.last
+      when "Rendering"
+        "#{file_name(segments[-2])} Template"
+      when "Partial"
+        "#{file_name(segments[-2])} Partial"
+      when ".rhtml Processing"
+        "ERB compilation"
+      else 
+        segments[1..-1]
+    end
+  end
+  def template_label
+    case segments.last
+      when "Rendering"
+        "#{file_name(segments[1..-2].join(NewRelic::MetricParser::SEPARATOR))} Template"
+      when "Partial"
+        "#{file_name(segments[1..-2].join(NewRelic::MetricParser::SEPARATOR))} Partial"
+      when ".rhtml Processing"
+        "ERB compilation"
+      else 
+        segments[1..-1].join("/")
+    end
+  end
+  
+  def short_name
+    segments[1..-2].join(NewRelic::MetricParser::SEPARATOR)
+  end
+  
+  def controller_name
+    template_label
+  end
+
+  def action_name
+    # Strip the extension
+    segments[-2].gsub(/\..*$/, "")
+  end
+
+  def developer_name
+    template_label
+  end
+  
+  def url
+    '/' + file_name(segments[1..-2].join('/'))
+  end
+  private
+  def file_name(path)
+    label = path.gsub /\.html\.rhtml/, '.rhtml'
+    label = segments[1] if label.empty?
+    label
+  end
+end