RubyGems - mmtrix_rpm - Versions diffs - 1.0.0.1 - Mend

mmtrix_rpm 1.0.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1036) hide show

data/lib/mmtrix/rack/browser_monitoring.rb ADDED Viewed

@@ -0,0 +1,150 @@
+# 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 'rack'
+require 'mmtrix/rack/agent_middleware'
+require 'mmtrix/agent/instrumentation/middleware_proxy'
+module Mmtrix::Rack
+  # This middleware is used by the agent for the Real user monitoring (RUM)
+  # feature, and will usually be automatically injected in the middleware chain.
+  # If automatic injection is not working, you may manually use it in your
+  # middleware chain instead.
+  #
+  # @api public
+  #
+  class BrowserMonitoring < AgentMiddleware
+    # The maximum number of bytes of the response body that we will
+    # examine in order to look for a RUM insertion point.
+    SCAN_LIMIT = 50_000
+    CONTENT_TYPE        = 'Content-Type'.freeze
+    CONTENT_DISPOSITION = 'Content-Disposition'.freeze
+    ATTACHMENT          = 'attachment'.freeze
+    TEXT_HTML           = 'text/html'.freeze
+    BODY_START          = "<body".freeze
+    HEAD_START          = "<head".freeze
+    GT                  = ">".freeze
+    def traced_call(env)
+      result = @app.call(env)   # [status, headers, response]
+      js_to_inject = Mmtrix::Agent.browser_timing_header
+      if (js_to_inject != "") && should_instrument?(env, result[0], result[1])
+        response_string = autoinstrument_source(result[2], result[1], js_to_inject)
+        env[ALREADY_INSTRUMENTED_KEY] = true
+        if response_string
+          response = Rack::Response.new(response_string, result[0], result[1])
+          response.finish
+        else
+          result
+        end
+      else
+        result
+      end
+    end
+    ALREADY_INSTRUMENTED_KEY = "mmtrix.browser_monitoring_already_instrumented"
+    def should_instrument?(env, status, headers)
+      Mmtrix::Agent.config[:'browser_monitoring.auto_instrument'] &&
+        status == 200 &&
+        !env[ALREADY_INSTRUMENTED_KEY] &&
+        is_html?(headers) &&
+        !is_attachment?(headers) &&
+        !is_streaming?(env)
+    end
+    def is_html?(headers)
+      headers[CONTENT_TYPE] && headers[CONTENT_TYPE].include?(TEXT_HTML)
+    end
+    def is_attachment?(headers)
+      headers[CONTENT_DISPOSITION] && headers[CONTENT_DISPOSITION].include?(ATTACHMENT)
+    end
+    def is_streaming?(env)
+      return false unless defined?(ActionController::Live)
+      env['action_controller.instance'].class.included_modules.include?(ActionController::Live)
+    end
+    CHARSET_RE         = /<\s*meta[^>]+charset\s*=[^>]*>/im.freeze
+    X_UA_COMPATIBLE_RE = /<\s*meta[^>]+http-equiv\s*=\s*['"]x-ua-compatible['"][^>]*>/im.freeze
+    def autoinstrument_source(response, headers, js_to_inject)
+      source = gather_source(response)
+      close_old_response(response)
+      return nil unless source
+      # Only scan the first 50k (roughly) then give up.
+      beginning_of_source = source[0..SCAN_LIMIT]
+      if body_start = find_body_start(beginning_of_source)
+        meta_tag_positions = [
+          find_x_ua_compatible_position(beginning_of_source),
+          find_charset_position(beginning_of_source)
+        ].compact
+        if !meta_tag_positions.empty?
+          insertion_index = meta_tag_positions.max
+        else
+          insertion_index = find_end_of_head_open(beginning_of_source) || body_start
+        end
+        if insertion_index
+          source = source[0...insertion_index] <<
+            js_to_inject <<
+            source[insertion_index..-1]
+        else
+          Mmtrix::Agent.logger.debug "Skipping RUM instrumentation. Could not properly determine location to inject script."
+        end
+      else
+        msg = "Skipping RUM instrumentation. Unable to find <body> tag in first #{SCAN_LIMIT} bytes of document."
+        Mmtrix::Agent.logger.log_once(:warn, :rum_insertion_failure, msg)
+        Mmtrix::Agent.logger.debug(msg)
+      end
+      source
+    rescue => e
+      Mmtrix::Agent.logger.debug "Skipping RUM instrumentation on exception.", e
+      nil
+    end
+    def gather_source(response)
+      source = nil
+      response.each {|fragment| source ? (source << fragment.to_s) : (source = fragment.to_s)}
+      source
+    end
+    # Per "The Response > The Body" section of Rack spec, we should close
+    # if our response is able. http://rack.rubyforge.org/doc/SPEC.html
+    def close_old_response(response)
+      if response.respond_to?(:close)
+        response.close
+      end
+    end
+    def find_body_start(beginning_of_source)
+      beginning_of_source.index(BODY_START)
+    end
+    def find_x_ua_compatible_position(beginning_of_source)
+      match = X_UA_COMPATIBLE_RE.match(beginning_of_source)
+      match.end(0) if match
+    end
+    def find_charset_position(beginning_of_source)
+      match = CHARSET_RE.match(beginning_of_source)
+      match.end(0) if match
+    end
+    def find_end_of_head_open(beginning_of_source)
+      head_open = beginning_of_source.index(HEAD_START)
+      beginning_of_source.index(GT, head_open) + 1 if head_open
+    end
+  end
+end

data/lib/mmtrix/rack/developer_mode/segment_summary.rb ADDED Viewed

@@ -0,0 +1,56 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+# summarizes performance data for all calls to segments
+# with the same metric_name
+module Mmtrix
+  module Rack
+    class DeveloperMode
+      class SegmentSummary
+        attr_accessor :metric_name, :total_time, :exclusive_time, :call_count, :current_nest_count
+        def initialize(metric_name, sample)
+          @metric_name = metric_name
+          @total_time, @exclusive_time, @call_count = 0,0,0
+          @sample = sample
+          @current_nest_count = 0
+        end
+        def <<(segment)
+          if metric_name != segment.metric_name
+            raise ArgumentError, "Metric Name Mismatch: #{segment.metric_name} != #{metric_name}"
+          end
+          # a nested segment should use the sum of the top level totals
+          @total_time += segment.duration if current_nest_count == 0
+          @exclusive_time += segment.exclusive_duration
+          @call_count += 1
+        end
+        def average_time
+          @total_time / @call_count
+        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
+        def total_time_percentage
+          return 0 unless @total_time && @sample.duration && @sample.duration > 0
+          @total_time / @sample.duration
+        end
+        def ui_name
+          return @metric_name if @metric_name == 'Remainder'
+          Mmtrix::MetricParser::MetricParser.parse(@metric_name).developer_name
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/rack/developer_mode.rb ADDED Viewed

@@ -0,0 +1,321 @@
+# 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 'rack/request'
+require 'rack/response'
+require 'rack/file'
+require 'conditional_vendored_metric_parser'
+require 'mmtrix/collection_helper'
+require 'mmtrix/metric_parser/metric_parser'
+require 'mmtrix/rack/agent_middleware'
+require 'mmtrix/agent/instrumentation/middleware_proxy'
+module Mmtrix
+  module Rack
+    # This middleware provides the 'developer mode' feature of mmtrix_rpm,
+    # which allows you to see data about local web transactions in development
+    # mode immediately without needing to send this data to Mmtrix's servers.
+    #
+    # Enabling developer mode has serious performance and security impact, and
+    # thus you should never use this middleware in a production or non-local
+    # environment.
+    #
+    # This middleware should be automatically inserted in most contexts, but if
+    # automatic middleware insertion fails, you may manually insert it into your
+    # middleware chain.
+    #
+    # @api public
+    #
+    class DeveloperMode < AgentMiddleware
+      VIEW_PATH   = File.expand_path('../../../../ui/views/'  , __FILE__)
+      HELPER_PATH = File.expand_path('../../../../ui/helpers/', __FILE__)
+      require File.join(HELPER_PATH, 'developer_mode_helper.rb')
+      require 'mmtrix/rack/developer_mode/segment_summary'
+      include Mmtrix::DeveloperModeHelper
+      class << self
+        attr_writer :profiling_enabled
+      end
+      def self.profiling_enabled?
+        @profiling_enabled
+      end
+      def traced_call(env)
+        return @app.call(env) unless /^\/mmtrix/ =~ ::Rack::Request.new(env).path_info
+        dup._call(env)
+      end
+      protected
+      def _call(env)
+        Mmtrix::Agent.ignore_transaction
+        @req = ::Rack::Request.new(env)
+        @rendered = false
+        case @req.path_info
+        when /profile/
+          profile
+        when /file/
+          ::Rack::File.new(VIEW_PATH).call(env)
+        when /index/
+          index
+        when /threads/
+          threads
+        when /reset/
+          reset
+        when /show_sample_detail/
+          show_sample_data
+        when /show_sample_summary/
+          show_sample_data
+        when /show_sample_sql/
+          show_sample_data
+        when /explain_sql/
+          explain_sql
+        when /^\/mmtrix\/?$/
+          index
+        else
+          @app.call(env)
+        end
+      end
+      private
+      def index
+        get_samples
+        render(:index)
+      end
+      def reset
+        Mmtrix::Agent.instance.transaction_sampler.reset!
+        Mmtrix::Agent.instance.sql_sampler.reset!
+        ::Rack::Response.new{|r| r.redirect('/mmtrix/')}.finish
+      end
+      def explain_sql
+        get_segment
+        return render(:sample_not_found) unless @sample
+        @sql = @segment[:sql]
+        @trace = @segment[:backtrace]
+        if Mmtrix::Agent.agent.record_sql == :obfuscated
+          @obfuscated_sql = @segment.obfuscated_sql
+        end
+        _headers, explanations = @segment.explain_sql
+        if explanations
+          @explanation = explanations
+          if !@explanation.blank?
+            first_row = @explanation.first
+            # Show the standard headers if it looks like a mysql explain plan
+            # Otherwise show blank headers
+            if first_row.length < Mmtrix::MYSQL_EXPLAIN_COLUMNS.length
+              @row_headers = nil
+            else
+              @row_headers = Mmtrix::MYSQL_EXPLAIN_COLUMNS
+            end
+          end
+        end
+        render(:explain_sql)
+      end
+      def profile
+        should_be_on = (params['start'] == 'true')
+        Mmtrix::Rack::DeveloperMode.profiling_enabled = should_be_on
+        index
+      end
+      def threads
+        render(:threads)
+      end
+      def render(view, layout=true)
+        add_rack_array = true
+        if view.is_a? Hash
+          layout = false
+          if view[:object]
+            # object *is* used here, as it is capture in the binding below
+            object = view[:object]
+          end
+          if view[:collection]
+            return view[:collection].map do |obj|
+              render({:partial => view[:partial], :object => obj})
+            end.join(' ')
+          end
+          if view[:partial]
+            add_rack_array = false
+            view = "_#{view[:partial]}"
+          end
+        end
+        binding = Proc.new {}.binding
+        if layout
+          body = render_with_layout(view) do
+            render_without_layout(view, binding)
+          end
+        else
+          body = render_without_layout(view, binding)
+        end
+        if add_rack_array
+          ::Rack::Response.new(body, 200, {'Content-Type' => 'text/html'}).finish
+        else
+          body
+        end
+      end
+      # You have to call this with a block - the contents returned from
+      # that block are interpolated into the layout
+      def render_with_layout(view)
+        body = ERB.new(File.read(File.join(VIEW_PATH, 'layouts/mmtrix_default.rhtml')))
+        body.result(Proc.new {}.binding)
+      end
+      # you have to pass a binding to this (a proc) so that ERB can have
+      # access to helper functions and local variables
+      def render_without_layout(view, binding)
+        ERB.new(File.read(File.join(VIEW_PATH, 'mmtrix', view.to_s + '.rhtml')), nil, nil, 'frobnitz').result(binding)
+      end
+      def content_tag(tag, contents, opts={})
+        opt_values = opts.map {|k, v| "#{k}=\"#{v}\"" }.join(' ')
+        "<#{tag} #{opt_values}>#{contents}</#{tag}>"
+      end
+      def sample
+        @sample || @samples[0]
+      end
+      def params
+        @req.params
+      end
+      def segment
+        @segment
+      end
+      def show_sample_data
+        get_sample
+        return render(:sample_not_found) unless @sample
+        @request_params = request_attributes_for(@sample)
+        @custom_params = custom_attributes_for(@sample)
+        controller_metric = @sample.transaction_name
+        metric_parser = Mmtrix::MetricParser::MetricParser.for_metric_named controller_metric
+        @sample_controller_name = metric_parser.controller_name
+        @sample_action_name = metric_parser.action_name
+        @sql_segments = sql_segments(@sample)
+        if params['d']
+          @sql_segments.sort!{|a,b| b.duration <=> a.duration }
+        end
+        sort_method = params['sort'] || :total_time
+        @profile_options = {:min_percent => 0.5, :sort_method => sort_method.to_sym}
+        render(:show_sample)
+      end
+      def get_samples
+        @samples = Mmtrix::Agent.instance.transaction_sampler.dev_mode_sample_buffer.samples.select do |sample|
+          sample.transaction_name != nil
+        end
+        return @samples = @samples.sort_by(&:duration).reverse                   if params['h']
+        return @samples = @samples.sort{|x,y| x.params[:uri] <=> y.params[:uri]} if params['u']
+        @samples = @samples.reverse
+      end
+      def get_sample
+        get_samples
+        id = params['id']
+        sample_id = id.to_i
+        @samples.each do |s|
+          if s.sample_id == sample_id
+            @sample = s
+            return
+          end
+        end
+      end
+      def get_segment
+        get_sample
+        return unless @sample
+        segment_id = params['segment'].to_i
+        @segment = @sample.root_node.find_node(segment_id)
+      end
+      def custom_attributes_for(sample)
+        sample.attributes.custom_attributes_for(Mmtrix::Agent::AttributeFilter::DST_DEVELOPER_MODE)
+      end
+      REQUEST_PARAMETERS_PREFIX = "request.parameters".freeze
+      def request_attributes_for(sample)
+        agent_attributes = sample.attributes.agent_attributes_for(Mmtrix::Agent::AttributeFilter::DST_DEVELOPER_MODE)
+        agent_attributes.inject({}) do |memo, (key, value)|
+          memo[key] = value if key.to_s.start_with?(REQUEST_PARAMETERS_PREFIX)
+          memo
+        end
+      end
+      def breakdown_data(sample, limit = nil)
+        metric_hash = {}
+        sample.each_node_with_nest_tracking do |node|
+          unless node == sample.root_node
+            metric_name = node.metric_name
+            metric_hash[metric_name] ||= SegmentSummary.new(metric_name, sample)
+            metric_hash[metric_name] << node
+            metric_hash[metric_name]
+          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
+        # add one last node for the remaining time if any
+        remainder = sample.duration
+        data.each do |node|
+          remainder -= node.exclusive_time
+        end
+        if (remainder*1000).round > 0
+          remainder_summary = SegmentSummary.new('Remainder', sample)
+          remainder_summary.total_time = remainder_summary.exclusive_time = remainder
+          remainder_summary.call_count = 1
+          data << remainder_summary
+        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(sample, show_non_sql_segments = true)
+        segments = []
+        sample.each_node do |segment|
+          segments << segment if segment[:sql] || segment[:sql_obfuscated] || (show_non_sql_segments && segment[:key])
+        end
+        segments
+      end
+    end
+  end
+end

data/lib/mmtrix/rack/error_collector.rb ADDED Viewed

@@ -0,0 +1,27 @@
+# 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/rack/agent_middleware'
+module Mmtrix::Rack
+  # This middleware is no longer used by the agent by default, but remains here
+  # for API compatibility purposes.
+  #
+  # You should remove any references to it from your config.ru or other rack
+  # middleware configuration files.
+  #
+  # The agent will instead now automatically collect errors for all Rack
+  # applications if automatic Rack middleware instrumentation is enabled (it is
+  # by default), or if you have manually added any Mmtrix middlewares into
+  # your middleware stack.
+  #
+  # @api public
+  # @deprecated
+  #
+  class ErrorCollector < AgentMiddleware
+    def traced_call(env)
+      @app.call(env)
+    end
+  end
+end

data/lib/mmtrix/rack.rb ADDED Viewed

@@ -0,0 +1,17 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+# @api public
+module Mmtrix
+  # This module contains Rack middlewares used by the Ruby agent.
+  #
+  # Generally, these middlewares should be injected automatically when starting
+  # your application. If automatic injection into the middleware chain is not
+  # working for some reason, you may also include them manually.
+  #
+  #
+  # @api public
+  module Rack
+  end
+end

data/lib/mmtrix/recipes/capistrano3.rb ADDED Viewed

@@ -0,0 +1,66 @@
+# 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 'capistrano/framework'
+namespace :mmtrix do
+  # notifies Mmtrix of a deployment
+  desc "Record a deployment in Mmtrix (mmtrix.com)"
+  task :notice_deployment do
+    run_locally do
+      environment = fetch(:mmtrix_rails_env, fetch(:rack_env, fetch(:rails_env, "production")))
+      require 'mmtrix/cli/command.rb'
+      begin
+        # allow overrides to be defined for revision, description, changelog, appname, and user
+        rev         = fetch(:mmtrix_revision)
+        description = fetch(:mmtrix_desc)
+        changelog   = fetch(:mmtrix_changelog)
+        appname     = fetch(:mmtrix_appname)
+        user        = fetch(:mmtrix_user)
+        license_key = fetch(:mmtrix_license_key)
+        unless scm == :none
+          changelog ||= lookup_changelog
+          rev       ||= fetch(:current_revision)
+        end
+        new_revision = rev
+        deploy_options = {
+          :environment => environment,
+          :revision    => new_revision,
+          :changelog   => changelog,
+          :description => description,
+          :appname     => appname,
+          :user        => user,
+          :license_key => license_key
+        }
+        debug "Uploading deployment to Mmtrix"
+        deployment = Mmtrix::Cli::Deployments.new deploy_options
+        deployment.run
+        info "Uploaded deployment information to Mmtrix"
+      rescue Mmtrix::Cli::Command::CommandFailure => e
+        info e.message
+      rescue => e
+        info "Error creating Mmtrix deployment (#{e})\n#{e.backtrace.join("\n")}"
+      end
+    end
+  end
+  def lookup_changelog
+    debug "Retrieving changelog for Mmtrix Deployment details"
+    previous_revision = fetch(:previous_revision)
+    current_revision = fetch(:current_revision)
+    if scm == :git
+      log_command = "git log --no-color --pretty=format:'  * %an: %s' " +
+                    "--abbrev-commit --no-merges #{previous_revision}..#{current_revision}"
+      `#{log_command}`
+    end
+  end
+end