mmtrix_rpm 1.0.0.1

data/lib/mmtrix/agent/instrumentation/sinatra.rb

@@ -0,0 +1,188 @@
+# 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/agent/instrumentation/controller_instrumentation'
+require 'mmtrix/agent/instrumentation/sinatra/transaction_namer'
+require 'mmtrix/agent/instrumentation/sinatra/ignorer'
+
+DependencyDetection.defer do
+  @name = :sinatra
+
+  depends_on do
+    !Mmtrix::Agent.config[:disable_sinatra] &&
+      defined?(::Sinatra) && defined?(::Sinatra::Base) &&
+      Sinatra::Base.private_method_defined?(:dispatch!) &&
+      Sinatra::Base.private_method_defined?(:process_route) &&
+      Sinatra::Base.private_method_defined?(:route_eval)
+  end
+
+  executes do
+    ::Mmtrix::Agent.logger.info 'Installing Sinatra instrumentation'
+  end
+
+  executes do
+    ::Sinatra::Base.class_eval do
+      include Mmtrix::Agent::Instrumentation::Sinatra
+
+      alias dispatch_without_mmtrix dispatch!
+      alias dispatch! dispatch_with_mmtrix
+
+      alias process_route_without_mmtrix process_route
+      alias process_route process_route_with_mmtrix
+
+      alias route_eval_without_mmtrix route_eval
+      alias route_eval route_eval_with_mmtrix
+
+      register Mmtrix::Agent::Instrumentation::Sinatra::Ignorer
+    end
+
+    module ::Sinatra
+      register Mmtrix::Agent::Instrumentation::Sinatra::Ignorer
+    end
+  end
+
+  executes do
+    if Sinatra::Base.respond_to?(:build)
+      # These requires are inside an executes block because they require rack, and
+      # we can't be sure that rack is available when this file is first required.
+      require 'mmtrix/rack/agent_hooks'
+      require 'mmtrix/rack/browser_monitoring'
+      require 'mmtrix/rack/error_collector'
+
+      ::Sinatra::Base.class_eval do
+        class << self
+          alias build_without_mmtrix build
+          alias build build_with_mmtrix
+        end
+      end
+    else
+      ::Mmtrix::Agent.logger.info("Skipping auto-injection of middleware for Sinatra - requires Sinatra 1.2.1+")
+    end
+  end
+end
+
+module Mmtrix
+  module Agent
+    module Instrumentation
+      # Mmtrix instrumentation for Sinatra applications.  Sinatra actions will
+      # appear in the UI similar to controller actions, and have breakdown charts
+      # and transaction traces.
+      #
+      # The actions in the UI will correspond to the pattern expression used
+      # to match them, not directly to full URL's.
+      module Sinatra
+        include ::Mmtrix::Agent::Instrumentation::ControllerInstrumentation
+
+        # Expected method for supporting ControllerInstrumentation
+        def mmtrix_request_headers(_)
+          request.env
+        end
+
+        def self.included(clazz)
+          clazz.extend(ClassMethods)
+        end
+
+        module ClassMethods
+          def mmtrix_middlewares
+            middlewares = [Mmtrix::Rack::BrowserMonitoring]
+            if Mmtrix::Rack::AgentHooks.needed?
+              middlewares << Mmtrix::Rack::AgentHooks
+            end
+            middlewares
+          end
+
+          def build_with_mmtrix(*args, &block)
+            unless Mmtrix::Agent.config[:disable_sinatra_auto_middleware]
+              mmtrix_middlewares.each do |middleware_class|
+                try_to_use(self, middleware_class)
+              end
+            end
+            build_without_mmtrix(*args, &block)
+          end
+
+          def try_to_use(app, clazz)
+            has_middleware = app.middleware.any? { |info| info[0] == clazz }
+            app.use(clazz) unless has_middleware
+          end
+        end
+
+        # Capture last route we've seen. Will set for transaction on route_eval
+        def process_route_with_mmtrix(*args, &block)
+          begin
+            env["mmtrix.last_route"] = args[0]
+          rescue => e
+            ::Mmtrix::Agent.logger.debug("Failed determining last route in Sinatra", e)
+          end
+
+          process_route_without_mmtrix(*args, &block)
+        end
+
+        # If a transaction name is already set, this call will tromple over it.
+        # This is intentional, as typically passing to a separate route is like
+        # an entirely separate transaction, so we pick up the new name.
+        #
+        # If we're ignored, this remains safe, since set_transaction_name
+        # care for the gating on the transaction's existence for us.
+        def route_eval_with_mmtrix(*args, &block)
+          begin
+            txn_name = TransactionNamer.transaction_name_for_route(env, request)
+            unless txn_name.nil?
+              ::Mmtrix::Agent::Transaction.set_default_transaction_name(
+                "#{self.class.name}/#{txn_name}", :sinatra)
+            end
+          rescue => e
+            ::Mmtrix::Agent.logger.debug("Failed during route_eval to set transaction name", e)
+          end
+
+          route_eval_without_mmtrix(*args, &block)
+        end
+
+        def dispatch_with_mmtrix #THREAD_LOCAL_ACCESS
+          request_params = get_request_params
+          filtered_params = ParameterFiltering::apply_filters(request.env, request_params || {})
+
+          name = TransactionNamer.initial_transaction_name(request)
+          perform_action_with_mmtrix_trace(:category => :sinatra,
+                                             :name => name,
+                                             :params => filtered_params) do
+            dispatch_and_notice_errors_with_mmtrix
+          end
+        end
+
+        def get_request_params
+          begin
+            @request.params
+          rescue => e
+            Mmtrix::Agent.logger.debug("Failed to get params from Rack request.", e)
+            nil
+          end
+        end
+
+        def dispatch_and_notice_errors_with_mmtrix
+          dispatch_without_mmtrix
+        ensure
+          # Will only see an error raised if :show_exceptions is true, but
+          # will always see them in the env hash if they occur
+          had_error = env.has_key?('sinatra.error')
+          ::Mmtrix::Agent.notice_error(env['sinatra.error']) if had_error
+        end
+
+        def do_not_trace?
+          Ignorer.should_ignore?(self, :routes)
+        end
+
+        # Overrides ControllerInstrumentation implementation
+        def ignore_apdex?
+          Ignorer.should_ignore?(self, :apdex)
+        end
+
+        # Overrides ControllerInstrumentation implementation
+        def ignore_enduser?
+          Ignorer.should_ignore?(self, :enduser)
+        end
+
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/instrumentation/sunspot.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+DependencyDetection.defer do
+  @name = :sunspot
+
+  depends_on do
+    defined?(::Sunspot)
+  end
+
+  executes do
+    ::Mmtrix::Agent.logger.info 'Installing Rails Sunspot instrumentation'
+  end
+
+  executes do
+    ::Sunspot.module_eval do
+      class << self
+        %w(index index!).each do |method|
+          add_method_tracer method, 'SolrClient/Sunspot/index'
+        end
+        add_method_tracer :commit, 'SolrClient/Sunspot/commit'
+
+        %w[search more_like_this].each do |method|
+          add_method_tracer method, 'SolrClient/Sunspot/query'
+        end
+        %w[remove remove! remove_by_id remove_by_id! remove_all remove_all!].each do |method|
+          add_method_tracer method, 'SolrClient/Sunspot/delete'
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/instrumentation/typhoeus.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+DependencyDetection.defer do
+  named :typhoeus
+
+  depends_on do
+    defined?(Typhoeus) && defined?(Typhoeus::VERSION)
+  end
+
+  depends_on do
+    Mmtrix::Agent::Instrumentation::TyphoeusTracing.is_supported_version?
+  end
+
+  executes do
+    ::Mmtrix::Agent.logger.info 'Installing Typhoeus instrumentation'
+    require 'mmtrix/agent/cross_app_tracing'
+    require 'mmtrix/agent/http_clients/typhoeus_wrappers'
+  end
+
+  # Basic request tracing
+  executes do
+    Typhoeus.before do |request|
+      Mmtrix::Agent::Instrumentation::TyphoeusTracing.trace(request)
+
+      # Ensure that we always return a truthy value from the before block,
+      # otherwise Typhoeus will bail out of the instrumentation.
+      true
+    end
+  end
+
+  # Apply single TT node for Hydra requests until async support
+  executes do
+    class Typhoeus::Hydra
+      include Mmtrix::Agent::MethodTracer
+
+      def run_with_mmtrix(*args)
+        trace_execution_scoped("External/Multiple/Typhoeus::Hydra/run") do
+          run_without_mmtrix(*args)
+        end
+      end
+
+      alias run_without_mmtrix run
+      alias run run_with_mmtrix
+    end
+  end
+end
+
+
+module Mmtrix::Agent::Instrumentation::TyphoeusTracing
+
+  EARLIEST_VERSION = Mmtrix::VersionNumber.new("0.5.3")
+
+  def self.is_supported_version?
+    Mmtrix::VersionNumber.new(Typhoeus::VERSION) >= Mmtrix::Agent::Instrumentation::TyphoeusTracing::EARLIEST_VERSION
+  end
+
+  def self.request_is_hydra_enabled?(request)
+    request.respond_to?(:hydra) && request.hydra
+  end
+
+  def self.trace(request)
+    state = Mmtrix::Agent::TransactionState.tl_get
+    if state.is_execution_traced? && !request_is_hydra_enabled?(request)
+      wrapped_request = ::Mmtrix::Agent::HTTPClients::TyphoeusHTTPRequest.new(request)
+      t0 = Time.now
+      node = ::Mmtrix::Agent::CrossAppTracing.start_trace(state, t0, wrapped_request)
+      callback = Proc.new do
+        wrapped_response = ::Mmtrix::Agent::HTTPClients::TyphoeusHTTPResponse.new(request.response)
+        ::Mmtrix::Agent::CrossAppTracing.finish_trace(state, t0, node, wrapped_request, wrapped_response)
+      end
+      request.on_complete.unshift(callback)
+    end
+  rescue => e
+    Mmtrix::Agent.logger.error("Exception during trace setup for Typhoeus request", e)
+  end
+end

data/lib/mmtrix/agent/instrumentation.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.
+
+require 'mmtrix/agent'
+module Mmtrix
+  module Agent
+    # stub module that contains instrumentation defined in the
+    # instrumentation directory
+    module Instrumentation
+    end
+  end
+end

data/lib/mmtrix/agent/internal_agent_error.rb

@@ -0,0 +1,18 @@
+# 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 is the base class for all errors that we want to record through the
+# Mmtrix::Agent::ErrorCollector#notice_agent_error API. It provides the
+# standard support text at the front of the message, and is used for flagging
+# agent errors when checking queue limits.
+
+module Mmtrix
+  module Agent
+    class InternalAgentError < StandardError
+      def initialize(msg=nil)
+        super("Ruby agent internal error. Please contact support referencing this error.\n #{msg}")
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/javascript_instrumentor.rb

@@ -0,0 +1,196 @@
+# 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 'base64'
+require 'mmtrix/agent/obfuscator'
+require 'mmtrix/agent/transaction_timings'
+
+module Mmtrix
+  module Agent
+    class JavascriptInstrumentor
+      include Mmtrix::Coerce
+
+      RUM_KEY_LENGTH = 13
+
+      def initialize(event_listener)
+        event_listener.subscribe(:finished_configuring, &method(:log_configuration))
+      end
+
+      def log_configuration
+        Mmtrix::Agent.logger.debug("JS agent loader requested: #{Mmtrix::Agent.config[:'browser_monitoring.loader']}",
+                                     "JS agent loader debug: #{Mmtrix::Agent.config[:'browser_monitoring.debug']}",
+                                     "JS agent loader version: #{Mmtrix::Agent.config[:'browser_monitoring.loader_version']}")
+
+        if !Mmtrix::Agent.config[:'rum.enabled']
+          Mmtrix::Agent.logger.debug("Real User Monitoring is disabled for this agent. Edit your configuration to change this.")
+        end
+      end
+
+      def enabled?
+        Agent.config[:'rum.enabled'] && !!Agent.config[:beacon]
+      end
+
+      def obfuscator
+        @obfuscator ||= Mmtrix::Agent::Obfuscator.new(Mmtrix::Agent.config[:license_key], RUM_KEY_LENGTH)
+      end
+
+      def js_enabled_and_ready?
+        if !enabled?
+          ::Mmtrix::Agent.logger.log_once(:debug, :js_agent_disabled,
+                                            "JS agent instrumentation is disabled.")
+          false
+        elsif missing_config?(:js_agent_loader)
+          ::Mmtrix::Agent.logger.log_once(:debug, :missing_js_agent_loader,
+                                            "Missing :js_agent_loader. Skipping browser instrumentation.")
+          false
+        elsif missing_config?(:beacon)
+          ::Mmtrix::Agent.logger.log_once(:debug, :missing_beacon,
+                                            "Beacon configuration not received (yet?). Skipping browser instrumentation.")
+          false
+        elsif missing_config?(:browser_key)
+          ::Mmtrix::Agent.logger.log_once(:debug, :missing_browser_key,
+                                            "Browser key is not set. Skipping browser instrumentation.")
+          false
+        else
+          true
+        end
+      rescue => e
+        ::Mmtrix::Agent.logger.debug "Failure during 'js_enabled_and_ready?'", e
+        false
+      end
+
+      def insert_js?(state)
+        if !state.current_transaction
+          ::Mmtrix::Agent.logger.debug "Not in transaction. Skipping browser instrumentation."
+          false
+        elsif !state.is_transaction_traced?
+          ::Mmtrix::Agent.logger.debug "Transaction is not traced. Skipping browser instrumentation."
+          false
+        elsif !state.is_execution_traced?
+          ::Mmtrix::Agent.logger.debug "Execution is not traced. Skipping browser instrumentation."
+          false
+        elsif state.current_transaction.ignore_enduser?
+          ::Mmtrix::Agent.logger.debug "Ignore end user for this transaction is set. Skipping browser instrumentation."
+          false
+        else
+          true
+        end
+      rescue => e
+        ::Mmtrix::Agent.logger.debug "Failure during insert_js", e
+        false
+      end
+
+      def missing_config?(key)
+        value = Mmtrix::Agent.config[key]
+        value.nil? || value.empty?
+      end
+
+      def browser_timing_header #THREAD_LOCAL_ACCESS
+        return '' unless js_enabled_and_ready? # fast exit
+
+        state = Mmtrix::Agent::TransactionState.tl_get
+
+        return '' unless insert_js?(state) # slower exit
+
+        bt_config = browser_timing_config(state)
+        return '' if bt_config.empty?
+
+        bt_config + browser_timing_loader
+      rescue => e
+        ::Mmtrix::Agent.logger.debug "Failure during RUM browser_timing_header construction", e
+        ''
+      end
+
+      def browser_timing_loader
+        html_safe_if_needed("\n<script type=\"text/javascript\">#{Agent.config[:js_agent_loader]}</script>")
+      end
+
+      def browser_timing_config(state)
+        txn = state.current_transaction
+        return '' if txn.nil?
+
+        txn.freeze_name_and_execute_if_not_ignored do
+          data = data_for_js_agent(state)
+          json = Mmtrix::JSONWrapper.dump(data)
+          return html_safe_if_needed("\n<script type=\"text/javascript\">window.NREUM||(NREUM={});NREUM.info=#{json}</script>")
+        end
+
+        ''
+      end
+
+      BEACON_KEY           = "beacon".freeze
+      ERROR_BEACON_KEY     = "errorBeacon".freeze
+      LICENSE_KEY_KEY      = "licenseKey".freeze
+      APPLICATIONID_KEY    = "applicationID".freeze
+      TRANSACTION_NAME_KEY = "transactionName".freeze
+      QUEUE_TIME_KEY       = "queueTime".freeze
+      APPLICATION_TIME_KEY = "applicationTime".freeze
+      AGENT_KEY            = "agent".freeze
+      SSL_FOR_HTTP_KEY     = "sslForHttp".freeze
+      ATTS_KEY             = "atts".freeze
+      ATTS_USER_SUBKEY     = "u".freeze
+      ATTS_AGENT_SUBKEY    = "a".freeze
+
+      # NOTE: Internal prototyping may override this, so leave name stable!
+      def data_for_js_agent(state)
+        timings = state.timings
+
+        data = {
+          BEACON_KEY           => Mmtrix::Agent.config[:beacon],
+          ERROR_BEACON_KEY     => Mmtrix::Agent.config[:error_beacon],
+          LICENSE_KEY_KEY      => Mmtrix::Agent.config[:browser_key],
+          APPLICATIONID_KEY    => Mmtrix::Agent.config[:application_id],
+          TRANSACTION_NAME_KEY => obfuscator.obfuscate(timings.transaction_name_or_unknown),
+          QUEUE_TIME_KEY       => timings.queue_time_in_millis,
+          APPLICATION_TIME_KEY => timings.app_time_in_millis,
+          AGENT_KEY            => Mmtrix::Agent.config[:js_agent_file]
+        }
+
+        add_ssl_for_http(data)
+        add_attributes(data, state.current_transaction)
+
+        data
+      end
+
+      def add_ssl_for_http(data)
+        ssl_for_http = Mmtrix::Agent.config[:'browser_monitoring.ssl_for_http']
+        unless ssl_for_http.nil?
+          data[SSL_FOR_HTTP_KEY] = ssl_for_http
+        end
+      end
+
+      def add_attributes(data, txn)
+        return unless txn
+
+        atts = {}
+        append_custom_attributes!(txn, atts)
+        append_agent_attributes!(txn, atts)
+
+        unless atts.empty?
+          json = Mmtrix::JSONWrapper.dump(atts)
+          data[ATTS_KEY] = obfuscator.obfuscate(json)
+        end
+      end
+
+      def append_custom_attributes!(txn, atts)
+        custom_attributes = txn.attributes.custom_attributes_for(Mmtrix::Agent::AttributeFilter::DST_BROWSER_MONITORING)
+        unless custom_attributes.empty?
+          atts[ATTS_USER_SUBKEY] = custom_attributes
+        end
+      end
+
+      def append_agent_attributes!(txn, atts)
+        agent_attributes = txn.attributes.agent_attributes_for(Mmtrix::Agent::AttributeFilter::DST_BROWSER_MONITORING)
+        unless agent_attributes.empty?
+          atts[ATTS_AGENT_SUBKEY] = agent_attributes
+        end
+      end
+
+      def html_safe_if_needed(string)
+        string = string.html_safe if string.respond_to?(:html_safe)
+        string
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/log_once.rb

@@ -0,0 +1,39 @@
+# 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 Agent
+    module LogOnce
+      NUM_LOG_ONCE_KEYS = 1000
+
+      def log_once(level, key, *msgs)
+        @already_logged_lock.synchronize do
+          return if @already_logged.include?(key)
+
+          if @already_logged.size >= NUM_LOG_ONCE_KEYS && key.kind_of?(String)
+            # The reason for preventing too many keys in `logged` is for
+            # memory concerns.
+            # The reason for checking the type of the key is that we always want
+            # to allow symbols to log, since there are very few of them.
+            # The assumption here is that you would NEVER pass dynamically-created
+            # symbols, because you would never create symbols dynamically in the
+            # first place, as that would already be a memory leak in most Rubies,
+            # even if we didn't hang on to them all here.
+            return
+          end
+
+          @already_logged[key] = true
+        end
+
+        self.send(level, *msgs)
+      end
+
+      def clear_already_logged
+        @already_logged_lock.synchronize do
+          @already_logged = {}
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/memory_logger.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+# This file is distributed under Mmtrix's license terms.
+# See https://github.com/mmtrix/rpm/blob/master/LICENSE for complete details.
+
+# Base class for startup logging and testing in multiverse
+
+require 'mmtrix/agent/log_once'
+
+module Mmtrix
+  module Agent
+    class MemoryLogger
+      include LogOnce
+
+      def initialize
+        @already_logged_lock = Mutex.new
+        clear_already_logged
+
+        @messages = []
+      end
+
+      def is_startup_logger?
+        true
+      end
+
+      attr_accessor :messages, :level, :log_formatter
+
+      def fatal(*msgs, &blk)
+        messages << [:fatal, msgs, blk]
+      end
+
+      def error(*msgs, &blk)
+        messages << [:error, msgs, blk]
+      end
+
+      def warn(*msgs, &blk)
+        messages << [:warn, msgs, blk]
+      end
+
+      def info(*msgs, &blk)
+        messages << [:info, msgs, blk]
+      end
+
+      def debug(*msgs, &blk)
+        messages << [:debug, msgs, blk]
+      end
+
+      def log_exception(level, e, backtrace_level=level)
+        messages << [:log_exception, [level, e, backtrace_level]]
+      end
+
+      def dump(logger)
+        messages.each do |(method, args, blk)|
+          logger.send(method, *args, &blk)
+        end
+        messages.clear
+      end
+    end
+  end
+end