mmtrix_rpm 1.0.0.1

data/lib/mmtrix/agent/cross_app_tracing.rb

@@ -0,0 +1,339 @@
+# -*- ruby -*-
+# 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 CrossAppTracing
+
+      # Exception raised if there is a problem with cross app transactions.
+      class Error < RuntimeError; end
+
+      # The cross app response header for "outgoing" calls
+      NR_APPDATA_HEADER = 'X-Mmtrix-App-Data'
+
+      # The cross app id header for "outgoing" calls
+      NR_ID_HEADER = 'X-Mmtrix-ID'
+
+      # The cross app transaction header for "outgoing" calls
+      NR_TXN_HEADER = 'X-Mmtrix-Transaction'
+
+      # The cross app synthetics header
+      NR_SYNTHETICS_HEADER = 'X-Mmtrix-Synthetics'
+
+      # The index of the transaction GUID in the appdata header of responses
+      APPDATA_TXN_GUID_INDEX = 5
+
+
+      ###############
+      module_function
+      ###############
+
+      # Send the given +request+, adding metrics appropriate to the
+      # response when it comes back.
+      #
+      # See the documentation for +start_trace+ for an explanation of what
+      # +request+ should look like.
+      #
+      def tl_trace_http_request(request)
+        state = Mmtrix::Agent::TransactionState.tl_get
+        return yield unless state.is_execution_traced?
+
+        # It's important to set t0 outside the ensured block, otherwise there's
+        # a race condition if we raise after begin but before t0's set.
+        t0 = Time.now
+        begin
+          node = start_trace(state, t0, request)
+          response = yield
+        ensure
+          finish_trace(state, t0, node, request, response)
+        end
+
+        return response
+      end
+
+      # Set up the necessary state for cross-application tracing before the
+      # given +request+ goes out.
+      #
+      # The +request+ object passed in must respond to the following methods:
+      #
+      # * type - Return a String describing the underlying library being used
+      #          to make the request (e.g. 'Net::HTTP' or 'Typhoeus')
+      # * host - Return a String with the hostname or IP of the host being
+      #          communicated with.
+      # * method  - Return a String with the HTTP method name for this request
+      # * [](key) - Lookup an HTTP request header by name
+      # * []=(key, val) - Set an HTTP request header by name
+      # * uri  - Full URI of the request
+      #
+      # This method returns the transaction node if it was sucessfully pushed.
+      def start_trace(state, t0, request)
+        inject_request_headers(state, request) if cross_app_enabled?
+        stack = state.traced_method_stack
+        node = stack.push_frame(state, :http_request, t0)
+
+        return node
+      rescue => err
+        Mmtrix::Agent.logger.error "Uncaught exception while tracing HTTP request", err
+        return nil
+      rescue Exception => e
+        Mmtrix::Agent.logger.debug "Unexpected exception raised while tracing HTTP request", e
+
+        raise e
+      end
+
+
+      # Finish tracing the HTTP +request+ that started at +t0+ with the information in
+      # +response+ and the given +http+ connection.
+      #
+      # The +request+ must conform to the same interface described in the documentation
+      # for +start_trace+.
+      #
+      # The +response+ must respond to the following methods:
+      #
+      # * [](key) - Reads response headers.
+      # * to_hash - Converts response headers to a Hash
+      #
+      def finish_trace(state, t0, node, request, response)
+        unless t0
+          Mmtrix::Agent.logger.error("HTTP request trace finished without start time. This is probably an agent bug.")
+          return
+        end
+
+        t1 = Time.now
+        duration = t1.to_f - t0.to_f
+
+        begin
+          if request
+            # Figure out which metrics we need to report based on the request and response
+            # The last (most-specific) one is scoped.
+            metrics = metrics_for(request, response)
+            scoped_metric = metrics.pop
+
+            stats_engine.record_scoped_and_unscoped_metrics(
+              state, scoped_metric, metrics, duration)
+
+            # If we don't have node, something failed during start_trace so
+            # the current node isn't the HTTP call it should have been.
+            if node
+              node.name = scoped_metric
+              add_transaction_trace_parameters(request, response)
+            end
+          end
+        ensure
+          # If we have a node, always pop the traced method stack to avoid
+          # an inconsistent state, which prevents tracing of whole transaction.
+          if node
+            stack = state.traced_method_stack
+            stack.pop_frame(state, node, scoped_metric, t1)
+          end
+        end
+      rescue Mmtrix::Agent::CrossAppTracing::Error => err
+        Mmtrix::Agent.logger.debug "while cross app tracing", err
+      rescue => err
+        Mmtrix::Agent.logger.error "Uncaught exception while finishing an HTTP request trace", err
+      end
+
+      # Return +true+ if cross app tracing is enabled in the config.
+      def cross_app_enabled?
+        valid_cross_process_id? &&
+          valid_encoding_key? &&
+          cross_application_tracer_enabled?
+      end
+
+      def valid_cross_process_id?
+        Mmtrix::Agent.config[:cross_process_id] && Mmtrix::Agent.config[:cross_process_id].length > 0
+      end
+
+      def valid_encoding_key?
+        Mmtrix::Agent.config[:encoding_key] && Mmtrix::Agent.config[:encoding_key].length > 0
+      end
+
+      def cross_application_tracer_enabled?
+        Mmtrix::Agent.config[:"cross_application_tracer.enabled"] || Mmtrix::Agent.config[:cross_application_tracing]
+      end
+
+      # Fetcher for the cross app encoding key. Raises a
+      # Mmtrix::Agent::CrossAppTracing::Error if the key isn't configured.
+      def cross_app_encoding_key
+        Mmtrix::Agent.config[:encoding_key] or
+          raise Mmtrix::Agent::CrossAppTracing::Error, "No encoding_key set."
+      end
+
+      def obfuscator
+        @obfuscator ||= Mmtrix::Agent::Obfuscator.new(cross_app_encoding_key)
+      end
+
+      # Inject the X-Process header into the outgoing +request+.
+      def inject_request_headers(state, request)
+        cross_app_id = Mmtrix::Agent.config[:cross_process_id] or
+          raise Mmtrix::Agent::CrossAppTracing::Error, "no cross app ID configured"
+
+        state.is_cross_app_caller = true
+        txn_guid = state.request_guid
+        txn = state.current_transaction
+        if txn
+          trip_id   = txn.cat_trip_id(state)
+          path_hash = txn.cat_path_hash(state)
+
+          if txn.raw_synthetics_header
+            request[NR_SYNTHETICS_HEADER] = txn.raw_synthetics_header
+          end
+        end
+        txn_data  = Mmtrix::JSONWrapper.dump([txn_guid, false, trip_id, path_hash])
+
+        request[NR_ID_HEADER]  = obfuscator.obfuscate(cross_app_id)
+        request[NR_TXN_HEADER] = obfuscator.obfuscate(txn_data)
+
+      rescue Mmtrix::Agent::CrossAppTracing::Error => err
+        Mmtrix::Agent.logger.debug "Not injecting x-process header", err
+      end
+
+      def add_transaction_trace_parameters(request, response)
+        filtered_uri = ::Mmtrix::Agent::HTTPClients::URIUtil.filter_uri(request.uri)
+        transaction_sampler.add_node_parameters(:uri => filtered_uri)
+        if response && response_is_crossapp?(response)
+          add_cat_transaction_trace_parameters(response)
+        end
+      end
+
+
+      # Extract any custom parameters from +response+ if it's cross-application and
+      # add them to the current TT node.
+      def add_cat_transaction_trace_parameters( response )
+        appdata = extract_appdata( response )
+        transaction_sampler.add_node_parameters( \
+          :transaction_guid => appdata[APPDATA_TXN_GUID_INDEX] )
+      end
+
+
+      # Return the set of metric names that correspond to
+      # the given +request+ and +response+.
+      # +response+ may be nil in the case that the request produced an error
+      # without ever receiving an HTTP response.
+      def metrics_for( request, response )
+        metrics = common_metrics( request )
+
+        if response && response_is_crossapp?( response )
+          begin
+            metrics.concat metrics_for_crossapp_response( request, response )
+          rescue => err
+            # Fall back to regular metrics if there's a problem with x-process metrics
+            Mmtrix::Agent.logger.debug "%p while fetching x-process metrics: %s" %
+              [ err.class, err.message ]
+            metrics.concat metrics_for_regular_request( request )
+          end
+        else
+          metrics.concat metrics_for_regular_request( request )
+        end
+
+        return metrics
+      end
+
+
+      # Return an Array of metrics used for every response.
+      def common_metrics( request )
+        metrics = [ "External/all" ]
+        metrics << "External/#{request.host}/all"
+
+        if Mmtrix::Agent::Transaction.recording_web_transaction?
+          metrics << "External/allWeb"
+        else
+          metrics << "External/allOther"
+        end
+
+        return metrics
+      end
+
+
+      # Returns +true+ if Cross Application Tracing is enabled, and the given +response+
+      # has the appropriate headers.
+      def response_is_crossapp?( response )
+        return false unless cross_app_enabled?
+        unless response[NR_APPDATA_HEADER]
+          return false
+        end
+
+        return true
+      end
+
+
+      # Return the set of metric objects appropriate for the given cross app
+      # +response+.
+      def metrics_for_crossapp_response( request, response )
+        xp_id, txn_name, _q_time, _r_time, _req_len, _ = extract_appdata( response )
+
+        check_crossapp_id( xp_id )
+        check_transaction_name( txn_name )
+
+        metrics = []
+        metrics << "ExternalApp/#{request.host}/#{xp_id}/all"
+        metrics << "ExternalTransaction/#{request.host}/#{xp_id}/#{txn_name}"
+
+        return metrics
+      end
+
+
+      # Extract x-process application data from the specified +response+ and return
+      # it as an array of the form:
+      #
+      #  [
+      #    <cross app ID>,
+      #    <transaction name>,
+      #    <queue time in seconds>,
+      #    <response time in seconds>,
+      #    <request content length in bytes>,
+      #    <transaction GUID>
+      #  ]
+      def extract_appdata( response )
+        appdata = response[NR_APPDATA_HEADER] or
+          raise Mmtrix::Agent::CrossAppTracing::Error,
+            "Can't derive metrics for response: no #{NR_APPDATA_HEADER} header!"
+
+        decoded_appdata = obfuscator.deobfuscate( appdata )
+        decoded_appdata.set_encoding( ::Encoding::UTF_8 ) if
+          decoded_appdata.respond_to?( :set_encoding )
+
+        return Mmtrix::JSONWrapper.load( decoded_appdata )
+      end
+
+
+      # Return the set of metric objects appropriate for the given (non-cross app)
+      # +request+.
+      def metrics_for_regular_request( request )
+        metrics = []
+        metrics << "External/#{request.host}/#{request.type}/#{request.method}"
+
+        return metrics
+      end
+
+
+      # Fetch a reference to the stats engine.
+      def stats_engine
+        Mmtrix::Agent.instance.stats_engine
+      end
+
+      def transaction_sampler
+        Mmtrix::Agent.instance.transaction_sampler
+      end
+
+      # Check the given +id+ to ensure it conforms to the format of a cross-application
+      # ID. Raises an Mmtrix::Agent::CrossAppTracing::Error if it doesn't.
+      def check_crossapp_id( id )
+        id =~ /\A\d+#\d+\z/ or
+          raise Mmtrix::Agent::CrossAppTracing::Error,
+            "malformed cross application ID %p" % [ id ]
+      end
+
+
+      # Check the given +name+ to ensure it conforms to the format of a valid transaction
+      # name.
+      def check_transaction_name( name )
+        # No-op -- apparently absolutely anything is a valid transaction name?
+        # This is here for when that inevitably comes back to haunt us.
+      end
+
+    end
+  end
+end

data/lib/mmtrix/agent/custom_event_aggregator.rb

@@ -0,0 +1,100 @@
+# 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/sized_buffer'
+require 'mmtrix/agent/attribute_processing'
+
+module Mmtrix
+  module Agent
+    class CustomEventAggregator
+      include Mmtrix::Coerce
+
+      TYPE             = 'type'.freeze
+      TIMESTAMP        = 'timestamp'.freeze
+      EVENT_TYPE_REGEX = /^[a-zA-Z0-9:_ ]+$/.freeze
+
+      DEFAULT_CAPACITY_KEY = :'custom_insights_events.max_samples_stored'
+
+      def initialize
+        @lock         = Mutex.new
+        @buffer       = SampledBuffer.new(Mmtrix::Agent.config[DEFAULT_CAPACITY_KEY])
+        @type_strings = Hash.new { |hash, key| hash[key] = key.to_s.freeze }
+        register_config_callbacks
+      end
+
+      def register_config_callbacks
+        Mmtrix::Agent.config.register_callback(DEFAULT_CAPACITY_KEY) do |max_samples|
+          Mmtrix::Agent.logger.debug "CustomEventAggregator max_samples set to #{max_samples}"
+          @lock.synchronize do
+            @buffer.capacity = max_samples
+          end
+        end
+      end
+
+      def record(type, attributes)
+        unless attributes.is_a? Hash
+          raise ArgumentError, "Expected Hash but got #{attributes.class}"
+        end
+
+        type = @type_strings[type]
+        unless type =~ EVENT_TYPE_REGEX
+          note_dropped_event(type)
+          return false
+        end
+
+        event = [
+          { TYPE => type, TIMESTAMP => Time.now.to_i },
+          AttributeProcessing.flatten_and_coerce(attributes)
+        ]
+
+        stored = @lock.synchronize do
+          @buffer.append(event)
+        end
+        stored
+      end
+
+      def harvest!
+        results = []
+        drop_count = 0
+        @lock.synchronize do
+          results.concat(@buffer.to_a)
+          drop_count += @buffer.num_dropped
+          @buffer.reset!
+        end
+        note_dropped_events(results.size, drop_count)
+        results
+      end
+
+      def note_dropped_events(captured_count, dropped_count)
+        total_count = captured_count + dropped_count
+        if dropped_count > 0
+          Mmtrix::Agent.logger.warn("Dropped #{dropped_count} custom events out of #{total_count}.")
+        end
+        engine = Mmtrix::Agent.instance.stats_engine
+        engine.tl_record_supportability_metric_count("Events/Customer/Seen"   ,    total_count)
+        engine.tl_record_supportability_metric_count("Events/Customer/Sent"   , captured_count)
+        engine.tl_record_supportability_metric_count("Events/Customer/Dropped",  dropped_count)
+      end
+
+      def merge!(events)
+        @lock.synchronize do
+          events.each do |event|
+            @buffer.append(event)
+          end
+        end
+      end
+
+      def reset!
+        @lock.synchronize { @buffer.reset! }
+      end
+
+      def note_dropped_event(type)
+        ::Mmtrix::Agent.logger.log_once(:warn, "dropping_event_of_type:#{type}",
+          "Invalid event type name '#{type}', not recording.")
+        @buffer.note_dropped
+      end
+
+    end
+  end
+end

data/lib/mmtrix/agent/database/obfuscation_helpers.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.
+
+module Mmtrix
+  module Agent
+    module Database
+      module ObfuscationHelpers
+        # Note that the following two regexes are applied to a reversed version
+        # of the query. This is why the backslash escape sequences (\' and \")
+        # appear reversed within them.
+        #
+        # Note that some database adapters (notably, PostgreSQL with
+        # standard_conforming_strings on and MySQL with NO_BACKSLASH_ESCAPES on)
+        # do not apply special treatment to backslashes within quoted string
+        # literals. We don't have an easy way of determining whether the
+        # database connection from which a query was captured was operating in
+        # one of these modes, but the obfuscation is done in such a way that it
+        # should not matter.
+        #
+        # Reversing the query string before obfuscation allows us to get around
+        # the fact that a \' appearing within a string may or may not terminate
+        # the string, because we know that a string cannot *start* with a \'.
+        REVERSE_SINGLE_QUOTES_REGEX = /'(?:''|'\\|[^'])*'/
+        REVERSE_ANY_QUOTES_REGEX    = /'(?:''|'\\|[^'])*'|"(?:""|"\\|[^"])*"/
+
+        NUMERICS_REGEX = /\b\d+\b/
+
+        # We take a conservative, overly-aggressive approach to obfuscating
+        # comments, and drop everything from the query after encountering any
+        # character sequence that could be a comment initiator. We do this after
+        # removal of string literals to avoid accidentally over-obfuscating when
+        # a string literal contains a comment initiator.
+        SQL_COMMENT_REGEX = Regexp.new('(?:/\*|--|#).*', Regexp::MULTILINE).freeze
+
+        # We use these to check whether the query contains any quote characters
+        # after obfuscation. If so, that's a good indication that the original
+        # query was malformed, and so our obfuscation can't reliabily find
+        # literals. In such a case, we'll replace the entire query with a
+        # placeholder.
+        LITERAL_SINGLE_QUOTE = "'".freeze
+        LITERAL_DOUBLE_QUOTE = '"'.freeze
+
+        PLACEHOLDER = '?'.freeze
+
+        def obfuscate_single_quote_literals(sql)
+          obfuscated = sql.reverse
+          obfuscated.gsub!(REVERSE_SINGLE_QUOTES_REGEX, PLACEHOLDER)
+          obfuscated.reverse!
+          obfuscated
+        end
+
+        def obfuscate_quoted_literals(sql)
+          obfuscated = sql.reverse
+          obfuscated.gsub!(REVERSE_ANY_QUOTES_REGEX, PLACEHOLDER)
+          obfuscated.reverse!
+          obfuscated
+        end
+
+        def obfuscate_numeric_literals(sql)
+          sql.gsub(NUMERICS_REGEX, PLACEHOLDER)
+        end
+
+        def remove_comments(sql)
+          sql.gsub(SQL_COMMENT_REGEX, PLACEHOLDER)
+        end
+
+        def contains_single_quotes?(str)
+          str.include?(LITERAL_SINGLE_QUOTE)
+        end
+
+        def contains_quotes?(str)
+          str.include?(LITERAL_SINGLE_QUOTE) || str.include?(LITERAL_DOUBLE_QUOTE)
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/database/obfuscator.rb

@@ -0,0 +1,80 @@
+# 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/database/obfuscation_helpers'
+
+module Mmtrix
+  module Agent
+    module Database
+      class Obfuscator
+        include Singleton
+        include ObfuscationHelpers
+
+        attr_reader :obfuscator
+
+        QUERY_TOO_LARGE_MESSAGE     = "Query too large (over 16k characters) to safely obfuscate"
+        FAILED_TO_OBFUSCATE_MESSAGE = "Failed to obfuscate SQL query - quote characters remained after obfuscation"
+
+        def initialize
+          reset
+        end
+
+        def reset
+          @obfuscator = method(:default_sql_obfuscator)
+        end
+
+        # Sets the sql obfuscator used to clean up sql when sending it
+        # to the server. Possible types are:
+        #
+        # :before => sets the block to run before the existing
+        # obfuscators
+        #
+        # :after => sets the block to run after the existing
+        # obfuscator(s)
+        #
+        # :replace => removes the current obfuscator and replaces it
+        # with the provided block
+        def set_sql_obfuscator(type, &block)
+          if type == :before
+            @obfuscator = Mmtrix::ChainedCall.new(block, @obfuscator)
+          elsif type == :after
+            @obfuscator = Mmtrix::ChainedCall.new(@obfuscator, block)
+          elsif type == :replace
+            @obfuscator = block
+          else
+            fail "unknown sql_obfuscator type #{type}"
+          end
+        end
+
+        def default_sql_obfuscator(sql)
+          if sql[-3,3] == '...'
+            return QUERY_TOO_LARGE_MESSAGE
+          end
+
+          stmt = sql.kind_of?(Statement) ? sql : Statement.new(sql)
+          obfuscate_double_quotes = stmt.adapter.to_s !~ /postgres|sqlite/
+
+          obfuscated = obfuscate_numeric_literals(stmt)
+
+          if obfuscate_double_quotes
+            obfuscated = obfuscate_quoted_literals(obfuscated)
+            obfuscated = remove_comments(obfuscated)
+            if contains_quotes?(obfuscated)
+              obfuscated = FAILED_TO_OBFUSCATE_MESSAGE
+            end
+          else
+            obfuscated = obfuscate_single_quote_literals(obfuscated)
+            obfuscated = remove_comments(obfuscated)
+            if contains_single_quotes?(obfuscated)
+              obfuscated = FAILED_TO_OBFUSCATE_MESSAGE
+            end
+          end
+
+
+          obfuscated.to_s # return back to a regular String
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/database/postgres_explain_obfuscator.rb

@@ -0,0 +1,46 @@
+# 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/database/obfuscation_helpers'
+
+module Mmtrix
+  module Agent
+    module Database
+      module PostgresExplainObfuscator
+        extend self
+
+        # Note that this regex can't be shared with the ones in the
+        # Database::Obfuscator class because here we don't look for
+        # backslash-escaped strings (and those regexes are backwards).
+        QUOTED_STRINGS_REGEX = /'(?:[^']|'')*'|"(?:[^"]|"")*"/
+        LABEL_LINE_REGEX     = /^([^:\n]*:\s+).*$/.freeze
+
+        def obfuscate(explain)
+          # First, we replace all single-quoted strings.
+          # This is necessary in order to deal with multi-line string constants
+          # embedded in the explain output.
+          #
+          # Note that we look for both single or double quotes but do not
+          # replace double quotes in order to avoid accidentally latching onto a
+          # single quote character embedded within a quoted identifier (such as
+          # a table name).
+          #
+          # Note also that we make no special provisions for backslash-escaped
+          # single quotes (\') because these are canonicalized to two single
+          # quotes ('') in the explain output.
+          explain.gsub!(QUOTED_STRINGS_REGEX) do |match|
+            match.start_with?('"') ? match : '?'
+          end
+
+          # Now, mask anything after the first colon (:).
+          # All parts of the query that can appear in the explain output are
+          # prefixed with "<label>: ", so we want to preserve the label, but
+          # remove the rest of the line.
+          explain.gsub!(LABEL_LINE_REGEX,   '\1?')
+          explain
+        end
+      end
+    end
+  end
+end