honkster-newrelic_rpm 2.13.1

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,136 @@
+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
+      %Q[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
+
+    # Category is a UI description of the general
+    # category of metrics for this metric.
+    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 segment_5; segments[5]; 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
+    # Return the list of dispatcher metrics that correspond to this metric.  That is,
+    # the summary metrics which should also be recorded when this metric is recorded.
+    def summary_metrics
+      []
+    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
+
+    # These would be reflected properly by method missing; consider
+    # this an optimization
+    def is_controller?; false; end
+    def is_transaction?; false; 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,28 @@
+class NewRelic::MetricParser::ActiveRecord < NewRelic::MetricParser
+  def is_active_record? ; true; end
+
+  def model_class
+    return segments[1]
+  end
+
+  def is_database?
+    true
+  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/apdex.rb

@@ -0,0 +1,88 @@
+require 'new_relic/metric_parser'
+module NewRelic
+  class MetricParser
+    class Apdex < NewRelic::MetricParser
+
+      CLIENT = 'Client'
+
+      # Convenience method for creating the appropriate client
+      # metric name.
+      def self.client_metric(apdex_t)
+        "Apdex/#{CLIENT}/#{apdex_t}"
+      end
+      def self.browser_client_metric(os, browser, version, apdex_t)
+        "#{self.client_metric(apdex_t)}/#{os}/#{browser}/#{version}"
+      end
+
+      def is_client?
+        segments[1] == CLIENT
+      end
+      def is_client_summary?
+        is_client? && segments.size == 3
+      end
+      def is_browser_summary?
+        is_client? && segments.size == 6
+      end
+      def is_summary?
+        segments.size == 1
+      end
+
+      # Apdex/Client/N
+      def apdex_t
+        is_client? && segments[2].to_f
+      end
+
+      def platform
+        is_browser_summary? && segments[3]
+      end
+
+      def browser
+        is_browser_summary? && segments[4]
+      end
+
+      def browser_version
+        is_browser_summary? && segments[5]
+      end
+
+      def user_agent
+        is_browser_summary? && segments[4..-1].join(" ")
+      end
+
+      def platform_and_user_agent
+        is_browser_summary? && segments[3..-1].join(" ")
+      end
+
+      def developer_name
+        case
+        when is_client? then "Apdex Client (#{apdex_t})"
+        when is_browser_summary? then "Apdex Client for #{os_and_browser} (#{apdex_t})"
+        when is_summary? then "Apdex"
+        else "Apdex #{segments[1..-1].join("/")}"
+        end
+      end
+
+      def short_name
+        # standard controller actions
+        if segments.length > 1
+          url
+        else
+          'All Frontend Urls'
+        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
+  end
+end

data/lib/new_relic/metric_parser/controller.rb

@@ -0,0 +1,62 @@
+class NewRelic::MetricParser::Controller < NewRelic::MetricParser
+
+  def is_controller?; true; end
+  def is_transaction?; 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.
+  # We only expect a lower case letter with Rails, so we'll be able to use camelize for
+  # that.
+  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
+
+  def is_web_transaction?
+    true
+  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
+
+  def summary_metrics
+    %w[HttpDispatcher]
+  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