mmtrix_rpm 1.0.0.1

data/lib/mmtrix/metric_data.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/coerce'
+
+module Mmtrix
+  class MetricData
+    # nil, or a Mmtrix::MetricSpec object if we have no cached ID
+    attr_reader :metric_spec
+    # nil or a cached integer ID for the metric from the collector.
+    attr_accessor :metric_id
+    # the actual statistics object
+    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
+
+    # assigns a new metric spec, and retains the old metric spec as
+    # @original_spec if it exists currently
+    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
+      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
+
+    include Mmtrix::Coerce
+
+    def to_collector_array(encoder=nil)
+      stat_key = metric_id || { 'name' => metric_spec.name, 'scope' => metric_spec.scope }
+      [ stat_key,
+        [
+          int(stats.call_count, stat_key),
+          float(stats.total_call_time, stat_key),
+          float(stats.total_exclusive_time, stat_key),
+          float(stats.min_call_time, stat_key),
+          float(stats.max_call_time, stat_key),
+          float(stats.sum_of_squares, stat_key)
+        ]
+      ]
+    end
+  end
+end

data/lib/mmtrix/metric_spec.rb

@@ -0,0 +1,81 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+# this struct uniquely defines a metric, optionally inside
+# the call scope of another metric
+class Mmtrix::MetricSpec
+  attr_reader   :name, :scope
+
+  # the maximum length of a metric name or metric scope
+  MAX_LENGTH = 255
+  LENGTH_RANGE = (0...MAX_LENGTH)
+  EMPTY_SCOPE = ''.freeze
+
+  def initialize(metric_name='', metric_scope=nil)
+    if metric_name.to_s.length > MAX_LENGTH
+      @name = metric_name.to_s[LENGTH_RANGE]
+    else
+      @name = metric_name.to_s
+    end
+
+    if metric_scope
+      if metric_scope.to_s.length > MAX_LENGTH
+        @scope = metric_scope.to_s[LENGTH_RANGE]
+      else
+        @scope = metric_scope.to_s
+      end
+    else
+      @scope = EMPTY_SCOPE
+    end
+  end
+
+  def ==(o)
+    self.eql?(o)
+  end
+
+  def eql? o
+    @name == o.name && @scope == o.scope
+  end
+
+  def hash
+    @name.hash ^ @scope.hash
+  end
+
+  # return a new metric spec if the given regex
+  # matches the name or scope.
+  def sub(pattern, replacement, apply_to_scope = true)
+    ::Mmtrix::Agent.logger.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)[LENGTH_RANGE]
+
+    if apply_to_scope
+      new_scope = (scope && scope.sub(pattern, replacement)[LENGTH_RANGE])
+    else
+      new_scope = scope
+    end
+
+    self.class.new new_name, new_scope
+  end
+
+  def to_s
+    return name if scope.empty?
+    "#{name}:#{scope}"
+  end
+
+  def inspect
+    "#<Mmtrix::MetricSpec '#{name}':'#{scope}'>"
+  end
+
+  def to_json(*a)
+    {'name' => name,
+    'scope' => scope}.to_json(*a)
+  end
+
+  def <=>(o)
+    namecmp = self.name <=> o.name
+    return namecmp if namecmp != 0
+    return (self.scope || '') <=> (o.scope || '')
+  end
+end

data/lib/mmtrix/metrics.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+module Mmtrix
+  module Metrics
+    CONTROLLER = "Controller"
+    DISPATCHER = "HttpDispatcher"
+    ACTIVE_RECORD = "ActiveRecord"
+    USER_TIME = "CPU/User Time"
+    MEMORY = "Memory/Physical"
+  end
+end

data/lib/mmtrix/noticed_error.rb

@@ -0,0 +1,164 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+require 'mmtrix/helper'
+require 'mmtrix/agent/attribute_filter'
+
+# This class encapsulates an error that was noticed by Mmtrix in a managed app.
+class Mmtrix::NoticedError
+  extend Mmtrix::CollectionHelper
+
+  attr_accessor :path, :timestamp, :message, :exception_class_name,
+                :request_uri, :file_name, :line_number, :stack_trace,
+                :attributes_from_notice_error, :attributes
+
+  attr_reader   :exception_id, :is_internal
+
+  STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE = "Message removed by Mmtrix 'strip_exception_messages' setting"
+
+  def initialize(path, exception, timestamp = Time.now)
+    @exception_id = exception.object_id
+    @path = path
+    @exception_class_name = exception.is_a?(Exception) ? exception.class.name : 'Error'
+
+    # It's critical that we not hold onto the exception class constant in this
+    # class. These objects get serialized for Resque to a process that might
+    # not have the original exception class loaded, so do all processing now
+    # while we have the actual exception!
+    @is_internal = (exception.class < Mmtrix::Agent::InternalAgentError)
+
+    if exception.nil?
+      @message = '<no message>'
+    elsif exception.respond_to?('original_exception')
+      @message = (exception.original_exception || exception).to_s
+    else # exception is not nil, but does not respond to original_exception
+      @message = exception.to_s
+    end
+
+
+    unless @message.is_a?(String)
+      # In pre-1.9.3, Exception.new({}).to_s.class != String
+      # That is, Exception#to_s may not return a String instance if one wasn't
+      # passed in upon creation of the Exception. So, try to generate a useful
+      # String representation of the exception message, falling back to failsafe
+      @message = String(@message.inspect) rescue '<unknown message type>'
+    end
+
+    # clamp long messages to 4k so that we don't send a lot of
+    # overhead across the wire
+    @message = @message[0..4095] if @message.length > 4096
+
+    # replace error message if enabled
+    if Mmtrix::Agent.config[:'strip_exception_messages.enabled'] &&
+       !self.class.passes_message_whitelist(exception.class)
+      @message = STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE
+    end
+
+    @timestamp = timestamp
+  end
+
+  # @exception_class has been deprecated in favor of the more descriptive
+  # @exception_class_name.
+  # @deprecated
+  def exception_class
+    exception_class_name
+  end
+
+  def ==(other)
+    if other.respond_to?(:exception_id)
+      exception_id == other.exception_id
+    else
+      false
+    end
+  end
+
+  def self.passes_message_whitelist(exception_class)
+    Mmtrix::Agent.config[:'strip_exception_messages.whitelist'].any? do |klass|
+      exception_class <= klass
+    end
+  end
+
+  include Mmtrix::Coerce
+
+  def to_collector_array(encoder=nil)
+    [ Mmtrix::Helper.time_to_millis(timestamp),
+      string(path),
+      string(message),
+      string(exception_class_name),
+      build_params ]
+  end
+
+  USER_ATTRIBUTES = "userAttributes".freeze
+  AGENT_ATTRIBUTES = "agentAttributes".freeze
+  INTRINSIC_ATTRIBUTES = "intrinsics".freeze
+
+  EMPTY_HASH = {}.freeze
+
+  DESTINATION = Mmtrix::Agent::AttributeFilter::DST_ERROR_COLLECTOR
+
+  def build_params
+    params = base_parameters
+    append_attributes(params, USER_ATTRIBUTES, merged_custom_attributes)
+    append_attributes(params, AGENT_ATTRIBUTES, build_agent_attributes)
+    append_attributes(params, INTRINSIC_ATTRIBUTES, build_intrinsic_attributes)
+    params
+  end
+
+  def base_parameters
+    params = {}
+    params[:request_uri] = request_uri if request_uri
+    params[:file_name]   = file_name   if file_name
+    params[:line_number] = line_number if line_number
+    params[:stack_trace] = stack_trace if stack_trace
+    params
+  end
+
+  # We can get custom attributes from two sources--the transaction, which we
+  # hold in @attributes, or passed options to notice_error which show up in
+  # @attributes_from_notice_error. Both need filtering, so merge them together
+  # in our Attributes class for consistent handling
+  def merged_custom_attributes
+    merged_attributes = Mmtrix::Agent::Transaction::Attributes.new(Mmtrix::Agent.instance.attribute_filter)
+
+    merge_custom_attributes_from_transaction(merged_attributes)
+    merge_custom_attributes_from_notice_error(merged_attributes)
+
+    merged_attributes.custom_attributes_for(DESTINATION)
+  end
+
+  def merge_custom_attributes_from_transaction(merged_attributes)
+    if @attributes
+      from_transaction = @attributes.custom_attributes_for(DESTINATION)
+      merged_attributes.merge_custom_attributes(from_transaction)
+    end
+  end
+
+  def merge_custom_attributes_from_notice_error(merged_attributes)
+    if @attributes_from_notice_error
+      from_notice_error = Mmtrix::NoticedError.normalize_params(@attributes_from_notice_error)
+      merged_attributes.merge_custom_attributes(from_notice_error)
+    end
+  end
+
+  def build_agent_attributes
+    if @attributes
+      @attributes.agent_attributes_for(DESTINATION)
+    else
+      EMPTY_HASH
+    end
+  end
+
+  def build_intrinsic_attributes
+    if @attributes
+      @attributes.intrinsic_attributes_for(DESTINATION)
+    else
+      EMPTY_HASH
+    end
+  end
+
+  def append_attributes(outgoing_params, outgoing_key, source_attributes)
+    outgoing_params[outgoing_key] = source_attributes || {}
+  end
+
+end