mmtrix_rpm 1.0.0.1

data/lib/mmtrix/agent/configuration/server_source.rb

@@ -0,0 +1,117 @@
+# 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 Configuration
+      class ServerSource < DottedHash
+        # These keys appear *outside* of the agent_config hash in the connect
+        # response, but should still be merged in as config settings to the
+        # main agent configuration.
+        TOP_LEVEL_KEYS = [
+          "apdex_t",
+          "application_id",
+          "beacon",
+          "browser_key",
+          "browser_monitoring.debug",
+          "browser_monitoring.loader",
+          "browser_monitoring.loader_version",
+          "cross_process_id",
+          "data_report_period",
+          "data_report_periods.analytic_event_data",
+          "encoding_key",
+          "error_beacon",
+          "js_agent_file",
+          "js_agent_loader",
+          "trusted_account_ids"
+        ]
+
+        def initialize(connect_reply, existing_config={})
+          merged_settings = {}
+
+          merge_top_level_keys(merged_settings, connect_reply)
+          merge_agent_config_hash(merged_settings, connect_reply)
+          fix_transaction_threshold(merged_settings)
+          filter_keys(merged_settings)
+
+          apply_feature_gates(merged_settings, connect_reply, existing_config)
+
+          # The value under this key is a hash mapping transaction name strings
+          # to apdex_t values. We don't want the nested hash to be flattened
+          # as part of the call to super below, so it skips going through
+          # merged_settings.
+          self[:web_transactions_apdex] = connect_reply['web_transactions_apdex']
+
+          # This causes keys in merged_settings to be symbolized and flattened
+          super(merged_settings)
+        end
+
+        def merge_top_level_keys(merged_settings, connect_reply)
+          TOP_LEVEL_KEYS.each do |key_name|
+            if connect_reply[key_name]
+              merged_settings[key_name] = connect_reply[key_name]
+            end
+          end
+        end
+
+        def merge_agent_config_hash(merged_settings, connect_reply)
+          if connect_reply['agent_config']
+            merged_settings.merge!(connect_reply['agent_config'])
+          end
+        end
+
+        def fix_transaction_threshold(merged_settings)
+          # when value is "apdex_f" remove the config and defer to default
+          if merged_settings['transaction_tracer.transaction_threshold'] =~ /apdex_f/i
+            merged_settings.delete('transaction_tracer.transaction_threshold')
+          end
+        end
+
+        def filter_keys(merged_settings)
+          merged_settings.delete_if do |key, _|
+            setting_spec = DEFAULTS[key.to_sym]
+            if setting_spec
+              if setting_spec[:allowed_from_server]
+                false # it's allowed, so don't delete it
+              else
+                Mmtrix::Agent.logger.warn("Ignoring server-sent config for '#{key}' - this setting cannot be set from the server")
+                true # delete it
+              end
+            else
+              Mmtrix::Agent.logger.debug("Ignoring unrecognized config key from server: '#{key}'")
+              true
+            end
+          end
+        end
+
+        # These feature gates are not intended to be bullet-proof, but only to
+        # avoid the overhead of collecting and transmitting additional data if
+        # the user's subscription level precludes its use. The server is the
+        # ultimate authority regarding subscription levels, so we expect it to
+        # do the real enforcement there.
+        def apply_feature_gates(merged_settings, connect_reply, existing_config)
+          gated_features = {
+            'transaction_tracer.enabled'     => 'collect_traces',
+            'slow_sql.enabled'               => 'collect_traces',
+            'error_collector.enabled'        => 'collect_errors',
+            'analytics_events.enabled'       => 'collect_analytics_events',
+            'custom_insights_events.enabled' => 'collect_custom_events'
+          }
+          gated_features.each do |config_key, gate_key|
+            if connect_reply.has_key?(gate_key)
+              allowed_by_server = connect_reply[gate_key]
+              requested_value   = ungated_value(config_key, merged_settings, existing_config)
+              effective_value   = (allowed_by_server && requested_value)
+              merged_settings[config_key] = effective_value
+            end
+          end
+        end
+
+        def ungated_value(key, merged_settings, existing_config)
+          merged_settings.has_key?(key) ? merged_settings[key] : existing_config[key.to_sym]
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/configuration/yaml_source.rb

@@ -0,0 +1,155 @@
+# 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/configuration/dotted_hash'
+
+module Mmtrix
+  module Agent
+    module Configuration
+      class YamlSource < DottedHash
+        attr_accessor :file_path, :failures
+
+        def initialize(path, env)
+          config    = {}
+          @failures = []
+
+          begin
+            @file_path = validate_config_file_path(path)
+            return unless @file_path
+
+            ::Mmtrix::Agent.logger.info("Reading configuration from #{path} (#{Dir.pwd})")
+            raw_file = File.read(@file_path)
+            erb_file = process_erb(raw_file)
+            config   = process_yaml(erb_file, env, config, @file_path)
+          rescue ScriptError, StandardError => e
+            log_failure("Failed to read or parse configuration file at #{path}", e)
+          end
+
+          substitute_transaction_threshold(config)
+          booleanify_values(config, 'agent_enabled', 'enabled')
+
+          super(config, true)
+        end
+
+        def failed?
+          !@failures.empty?
+        end
+
+        protected
+
+        def validate_config_file_path(path)
+          expanded_path = File.expand_path(path)
+
+          if path.empty? || !File.exist?(expanded_path)
+            warn_missing_config_file(expanded_path)
+            return
+          end
+
+          expanded_path
+        end
+
+        def warn_missing_config_file(path)
+          based_on        = 'unknown'
+          source          = ::Mmtrix::Agent.config.source(:config_path)
+          candidate_paths = [path]
+
+          case source
+          when DefaultSource
+            based_on = 'defaults'
+            candidate_paths = Mmtrix::Agent.config[:config_search_paths].map do |p|
+              File.expand_path(p)
+            end
+          when EnvironmentSource
+            based_on = 'environment variable'
+          when ManualSource
+            based_on = 'API call'
+          end
+
+          # This is not a failure, since we do support running without a
+          # mmtrix.yml (configured with just ENV). It is, however, uncommon,
+          # so warn about it since it's very likely to be unintended.
+          Mmtrix::Agent.logger.warn(
+            "No configuration file found. Working directory = #{Dir.pwd}",
+            "Looked in these locations (based on #{based_on}): #{candidate_paths.join(", ")}"
+          )
+        end
+
+        def process_erb(file)
+          begin
+            # Exclude lines that are commented out so failing Ruby code in an
+            # ERB template commented at the YML level is fine. Leave the line,
+            # though, so ERB line numbers remain correct.
+            file.gsub!(/^\s*#.*$/, '#')
+
+            # Next two are for populating the mmtrix.yml via erb binding, necessary
+            # when using the default mmtrix.yml file
+            generated_for_user = ''
+            license_key = ''
+
+            ERB.new(file).result(binding)
+          rescue ScriptError, StandardError => e
+            log_failure("Failed ERB processing configuration file. This is typically caused by a Ruby error in <% %> templating blocks in your mmtrix.yml file.", e)
+            nil
+          ensure
+            # Avoid warnings by using these again
+            generated_for_user = nil
+            license_key = nil
+          end
+        end
+
+        def process_yaml(file, env, config, path)
+          if file
+            confighash = with_yaml_engine { YAML.load(file) }
+            unless confighash.key?(env)
+              log_failure("Config file at #{path} doesn't include a '#{env}' section!")
+            end
+
+            config = confighash[env] || {}
+          end
+
+          config
+        end
+
+        def substitute_transaction_threshold(config)
+          if config['transaction_tracer'] &&
+              config['transaction_tracer']['transaction_threshold'] =~ /apdex_f/i
+            # when value is "apdex_f" remove the config and defer to default
+            config['transaction_tracer'].delete('transaction_threshold')
+          end
+        end
+
+        def with_yaml_engine
+          return yield unless Mmtrix::LanguageSupport.needs_syck?
+
+          yamler = ::YAML::ENGINE.yamler
+          ::YAML::ENGINE.yamler = 'syck'
+          result = yield
+          ::YAML::ENGINE.yamler = yamler
+          result
+        end
+
+
+        def booleanify_values(config, *keys)
+          # auto means defer ro default
+          keys.each do |option|
+            if config[option] == 'auto'
+              config.delete(option)
+            elsif !config[option].nil? && !is_boolean?(config[option])
+              config[option] = !!(config[option] =~ /yes|on|true/i)
+            end
+          end
+        end
+
+        def is_boolean?(value)
+          value == !!value
+        end
+
+        def log_failure(*messages)
+          ::Mmtrix::Agent.logger.error(*messages)
+          @failures << messages
+        end
+      end
+    end
+  end
+end

data/lib/mmtrix/agent/configuration.rb

@@ -0,0 +1,35 @@
+# 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/configuration/manager'
+require 'mmtrix/agent/configuration/dotted_hash'
+require 'mmtrix/agent/configuration/manual_source'
+
+# The agent's configuration is accessed through a configuration object exposed
+# by ::Mmtrix::Agent.config.  It provides a hash like interface to the
+# agent's settings.
+#
+# For example:
+# ::Mmtrix::Agent.config[:'transaction_tracer.enabled']
+# determines whether transaction tracing is enabled.  String and symbol keys
+# are treated indifferently and nested keys are collapsed and concatenated with
+# a dot (i.e. {:a => {:b => 'c'} becomes { 'a.b' => 'c'}).
+#
+# The agent reads configuration from a variety of sources. These sources are
+# modeled as a set of layers.  The top layer has the highest priority.  If the
+# top layer does not contain the requested setting the config object will search
+# through the subsequent layers returning the first value it finds.
+#
+# Configuration layers include EnvironmentSource (which reads settings from
+# ENV), ServerSource (which reads Server Side Config from Mmtrix's servers),
+# YamlSource (which reads from mmtrix.yml),  ManualSource (which reads
+# arguments passed to Mmtrix::Agent.manual_start or potentially other
+# methods), and Defaults (which contains default settings).
+#
+module Mmtrix
+  module Agent
+    module Configuration
+    end
+  end
+end

data/lib/mmtrix/agent/cross_app_monitor.rb

@@ -0,0 +1,178 @@
+# 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 'digest'
+
+require 'mmtrix/agent/inbound_request_monitor'
+require 'mmtrix/agent/transaction_state'
+require 'mmtrix/agent/threading/agent_thread'
+
+module Mmtrix
+  module Agent
+    class CrossAppMonitor < InboundRequestMonitor
+
+      MMTRIX_ID_HEADER      = 'X-Mmtrix-ID'
+      MMTRIX_TXN_HEADER     = 'X-Mmtrix-Transaction'
+      MMTRIX_APPDATA_HEADER = 'X-Mmtrix-App-Data'
+
+      MMTRIX_ID_HEADER_KEY    = 'HTTP_X_MMTRIX_ID'.freeze
+      MMTRIX_TXN_HEADER_KEY   = 'HTTP_X_MMTRIX_TRANSACTION'.freeze
+      CONTENT_LENGTH_HEADER_KEY = 'HTTP_CONTENT_LENGTH'.freeze
+
+      def on_finished_configuring(events)
+        register_event_listeners(events)
+      end
+
+      # Expected sequence of events:
+      #   :before_call will save our cross application request id to the thread
+      #   :after_call will write our response headers/metrics and clean up the thread
+      def register_event_listeners(events)
+        Mmtrix::Agent.logger.
+          debug("Wiring up Cross Application Tracing to events after finished configuring")
+
+        events.subscribe(:before_call) do |env| #THREAD_LOCAL_ACCESS
+          if should_process_request(env)
+            state = Mmtrix::Agent::TransactionState.tl_get
+
+            save_client_cross_app_id(state, env)
+            save_referring_transaction_info(state, env)
+            set_transaction_attributes(state)
+          end
+        end
+
+        events.subscribe(:after_call) do |env, (_status_code, headers, _body)| #THREAD_LOCAL_ACCESS
+          state = Mmtrix::Agent::TransactionState.tl_get
+
+          insert_response_header(state, env, headers)
+        end
+
+      end
+
+      def save_client_cross_app_id(state, request_headers)
+        state.client_cross_app_id = decoded_id(request_headers)
+      end
+
+      def clear_client_cross_app_id(state)
+        state.client_cross_app_id = nil
+      end
+
+      def save_referring_transaction_info(state, request_headers)
+        txn_header = request_headers[MMTRIX_TXN_HEADER_KEY] or return
+        txn_info = deserialize_header(txn_header, MMTRIX_TXN_HEADER)
+        state.referring_transaction_info = txn_info
+      end
+
+      def client_referring_transaction_guid(state)
+        info = state.referring_transaction_info or return nil
+        return info[0]
+      end
+
+      def client_referring_transaction_record_flag(state)
+        info = state.referring_transaction_info or return nil
+        return info[1]
+      end
+
+      def client_referring_transaction_trip_id(state)
+        info = state.referring_transaction_info or return nil
+        return info[2].is_a?(String) && info[2]
+      end
+
+      def client_referring_transaction_path_hash(state)
+        info = state.referring_transaction_info or return nil
+        return info[3].is_a?(String) && info[3]
+      end
+
+      def insert_response_header(state, request_headers, response_headers)
+        unless state.client_cross_app_id.nil?
+          txn = state.current_transaction
+          unless txn.nil?
+            txn.freeze_name_and_execute_if_not_ignored do
+              timings = state.timings
+              content_length = content_length_from_request(request_headers)
+
+              set_response_headers(state, response_headers, timings, content_length)
+              set_metrics(state.client_cross_app_id, timings)
+            end
+          end
+          clear_client_cross_app_id(state)
+        end
+      end
+
+      def should_process_request(request_headers)
+        return cross_app_enabled? && trusts?(request_headers)
+      end
+
+      def cross_app_enabled?
+        Mmtrix::Agent::CrossAppTracing.cross_app_enabled?
+      end
+
+      # Expects an ID of format "12#345", and will only accept that!
+      def trusts?(request)
+        id = decoded_id(request)
+        split_id = id.match(/(\d+)#\d+/)
+        return false if split_id.nil?
+
+        Mmtrix::Agent.config[:trusted_account_ids].include?(split_id.captures.first.to_i)
+      end
+
+      def set_response_headers(state, response_headers, timings, content_length)
+        response_headers[MMTRIX_APPDATA_HEADER] = build_payload(state, timings, content_length)
+      end
+
+      def build_payload(state, timings, content_length)
+        payload = [
+          Mmtrix::Agent.config[:cross_process_id],
+          timings.transaction_name,
+          timings.queue_time_in_seconds.to_f,
+          timings.app_time_in_seconds.to_f,
+          content_length,
+          state.request_guid
+        ]
+        payload = obfuscator.obfuscate(Mmtrix::JSONWrapper.dump(payload))
+      end
+
+      def set_transaction_attributes(state)
+        # We expect to get the before call to set the id (if we have it) before
+        # this, and then write our custom parameter when the transaction starts
+        return unless txn = state.current_transaction
+
+        if state.client_cross_app_id
+          txn.attributes.add_intrinsic_attribute(:client_cross_process_id, state.client_cross_app_id)
+        end
+
+        referring_guid = client_referring_transaction_guid(state)
+        if referring_guid
+          txn.attributes.add_intrinsic_attribute(:referring_transaction_guid, referring_guid)
+        end
+      end
+
+      def set_metrics(id, timings)
+        metric_name = "ClientApplication/#{id}/all"
+        Mmtrix::Agent.record_metric(metric_name, timings.app_time_in_seconds)
+      end
+
+      def decoded_id(request)
+        encoded_id = request[MMTRIX_ID_HEADER_KEY]
+        return "" if encoded_id.nil?
+
+        obfuscator.deobfuscate(encoded_id)
+      end
+
+      def content_length_from_request(request)
+        request[CONTENT_LENGTH_HEADER_KEY] || -1
+      end
+
+      def hash_transaction_name(identifier)
+        Digest::MD5.digest(identifier).unpack("@12N").first & 0xffffffff
+      end
+
+      def path_hash(txn_name, seed)
+        rotated    = ((seed << 1) | (seed >> 31)) & 0xffffffff
+        app_name   = Mmtrix::Agent.config.app_names.first
+        identifier = "#{app_name};#{txn_name}"
+        sprintf("%08x", rotated ^ hash_transaction_name(identifier))
+      end
+    end
+  end
+end