oneapm_rpm 1.1.0

data/lib/one_apm/configuration/environment_source.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+module OneApm
+  module Configuration
+    class EnvironmentSource < OneApm::Support::DottedHash
+
+      SUPPORTED_PREFIXES = /^one_apm_|^oneapm_/i
+      SPECIAL_CASE_KEYS  = [
+        'ONE_APM_ENV', # read by OneApm::Probe::Frameworks::Ruby
+        'ONE_APM_LOG'  # read by set_log_file
+      ]
+
+      attr_accessor :alias_map, :type_map
+
+      def initialize
+        set_log_file
+        set_config_file
+
+        @alias_map = {}
+        @type_map = {}
+
+        DEFAULTS.each do |config_setting, value|
+          self.type_map[config_setting] = value[:type]
+          set_aliases(config_setting, value)
+        end
+
+        set_values_from_one_apm_environment_variables
+      end
+
+      def set_aliases(config_setting, value)
+        set_dotted_alias(config_setting)
+
+        return unless value[:aliases]
+        value[:aliases].each do |config_alias|
+          self.alias_map[config_alias] = config_setting
+        end
+      end
+
+      def set_dotted_alias(original_config_setting)
+        config_setting = original_config_setting.to_s
+
+        if config_setting.include? '.'
+          config_alias = config_setting.gsub(/\./,'_').to_sym
+          self.alias_map[config_alias] = original_config_setting
+        end
+      end
+
+      def set_log_file
+        if ENV['ONE_APM_LOG']
+          if ENV['ONE_APM_LOG'].upcase == 'STDOUT'
+            self[:log_file_path] = self[:log_file_name] = 'STDOUT'
+          else
+            self[:log_file_path] = File.dirname(ENV['ONE_APM_LOG'])
+            self[:log_file_name] = File.basename(ENV['ONE_APM_LOG'])
+          end
+        end
+      end
+
+      def set_config_file
+        self[:config_path] = ENV['OACONFIG'] if ENV['OACONFIG']
+      end
+
+      def set_values_from_one_apm_environment_variables
+        nr_env_var_keys = collect_one_apm_environment_variable_keys
+
+        nr_env_var_keys.each do |key|
+          next if SPECIAL_CASE_KEYS.include?(key.upcase)
+          set_value_from_environment_variable(key)
+        end
+      end
+
+      def set_value_from_environment_variable(key)
+        config_key = convert_environment_key_to_config_key(key)
+        set_key_by_type(config_key, key)
+      end
+
+      def set_key_by_type(config_key, environment_key)
+        value = ENV[environment_key]
+        type = self.type_map[config_key]
+
+        if type == String
+          self[config_key] = value
+        elsif type == Fixnum
+          self[config_key] = value.to_i
+        elsif type == Float
+          self[config_key] = value.to_f
+        elsif type == Symbol
+          self[config_key] = value.to_sym
+        elsif type == OneApm::Configuration::Boolean
+          if value =~ /false|off|no/i
+            self[config_key] = false
+          elsif value != nil
+            self[config_key] = true
+          end
+        else
+          ::OneApm::Agent.logger.info("#{environment_key} does not have a corresponding configuration setting (#{config_key} does not exist).")
+          ::OneApm::Agent.logger.info("Run `rake oneapm:config:docs` or visit https://oneapm.com/docs/ruby/ruby-agent-configuration to see a list of available configuration settings.")
+          self[config_key] = value
+        end
+      end
+
+      def convert_environment_key_to_config_key(key)
+        stripped_key = key.gsub(SUPPORTED_PREFIXES, '').downcase.to_sym
+        self.alias_map[stripped_key] || stripped_key
+      end
+
+      def collect_one_apm_environment_variable_keys
+        ENV.keys.select { |key| key.match(SUPPORTED_PREFIXES) }
+      end
+
+    end
+  end
+end

data/lib/one_apm/configuration/high_security_source.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+require 'one_apm/configuration'
+
+module OneApm
+  module Configuration
+    class HighSecuritySource < OneApm::Support::DottedHash
+
+      OFF = "off".freeze
+      RAW = "raw".freeze
+      OBFUSCATED = "obfuscated".freeze
+
+      SET_TO_OBFUSCATED = [RAW, OBFUSCATED]
+
+      def initialize(local_settings)
+        super({
+          :ssl => true,
+
+          :capture_params           => false,
+          :'resque.capture_params'  => false,
+          :'sidekiq.capture_params' => false,
+
+          # These aren't strictly necessary as add_custom_parameters is
+          # directly responsible for ignoring incoming param, but we disallow
+          # attributes by these settings just to be safe
+          :'transaction_tracer.capture_attributes' => false,
+          :'error_collector.capture_attributes'    => false,
+          :'browser_monitoring.capture_attributes' => false,
+          :'analytics_events.capture_attributes'   => false,
+
+          :'transaction_tracer.record_sql' => record_sql_setting(local_settings, :'transaction_tracer.record_sql'),
+          :'slow_sql.record_sql'           => record_sql_setting(local_settings, :'slow_sql.record_sql'),
+          :'mongo.obfuscate_queries'       => true,
+
+          :'custom_insights_events.enabled'   => false,
+          :'strip_exception_messages.enabled' => true
+        })
+      end
+
+      def record_sql_setting(local_settings, key)
+        original_value  = local_settings[key]
+        result = if SET_TO_OBFUSCATED.include?(original_value)
+          OBFUSCATED
+        else
+          OFF
+        end
+
+        if result != original_value
+          OneApm::Agent.logger.info("Disabling setting #{key}='#{original_value}' because high security mode is enabled. Value will be '#{result}'")
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/one_apm/configuration/manual_source.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+
+require 'one_apm/support/dotted_hash'
+
+module OneApm
+  module Configuration
+    class ManualSource < OneApm::Support::DottedHash
+      def initialize(hash)
+        super(hash, true)
+      end
+    end
+  end
+end

data/lib/one_apm/configuration/server_source.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module OneApm
+  module Configuration
+    class ServerSource < OneApm::Support::DottedHash
+
+      def initialize(hash, existing_config = {})
+        if hash['transaction_tracer']
+          transaction_threshold = hash['transaction_tracer']['transaction_threshold']
+          if transaction_threshold =~ /apdex_f/i
+            # when value is "apdex_f" remove the config and defer to default
+            hash['transaction_tracer'].delete('transaction_threshold')
+          else
+            hash['transaction_tracer']['transaction_threshold'] = transaction_threshold.to_f
+          end
+        end
+
+        if hash['browser_monitoring']
+          hash['browser_monitoring']['auto_instrument'] = hash['browser_monitoring']['transform']
+        end
+
+        if hash['web_transactions_apdex']
+          self[:web_transactions_apdex] = hash.delete('web_transactions_apdex')
+        end
+
+        dotted_hash = OneApm::Support::DottedHash.new(hash).to_hash
+        apply_feature_gates(dotted_hash, existing_config)
+
+        super(dotted_hash)
+      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(server_config, 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 |feature, gate_key|
+          if server_config.has_key?(gate_key)
+            allowed_by_server = server_config[gate_key]
+            requested_value = ungated_value(feature, server_config, existing_config)
+            effective_value = (allowed_by_server && requested_value)
+            server_config[feature] = effective_value
+          end
+        end
+      end
+
+      def ungated_value(key, server_config, existing_config)
+        server_config.has_key?(key) ? server_config[key] : existing_config[key]
+      end
+    end
+  end
+end

data/lib/one_apm/configuration/yaml_source.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+require 'one_apm/configuration'
+require 'yaml'
+require 'erb'
+
+module OneApm
+  module Configuration
+    class YamlSource < OneApm::Support::DottedHash
+
+      attr_accessor :file_path
+
+      def initialize(path, env)
+        config = {}
+
+        begin
+          @file_path = validate_config_file_path(path)
+          return unless @file_path
+
+          OneApm::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
+          ::OneApm::Agent.logger.error("Failed to read or parse configuration file at #{path}", e)
+        end
+
+        substitute_transaction_threshold(config)
+        booleanify_values(config, 'agent_enabled', 'enabled', 'monitor_daemons')
+
+        super(config, true)
+      end
+
+      protected
+
+      def validate_config_file_path(path)
+        expanded_path = File.expand_path(path)
+
+        if path.empty? || !File.exists?(expanded_path)
+          warn_missing_config_file(expanded_path)
+          return
+        end
+
+        expanded_path
+      end
+
+      def warn_missing_config_file(path)
+        based_on        = 'unknown'
+        source          = ::OneApm::Agent.config.source(:config_path)
+        candidate_paths = [path]
+
+        case source
+        when DefaultSource
+          based_on = 'defaults'
+          candidate_paths = OneApm::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
+
+        OneApm::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 oneapm.yml via erb binding, necessary
+          # when using the default oneapm.yml file
+          generated_for_user = ''
+          license_key = ''
+
+          ERB.new(file).result(binding)
+        rescue ScriptError, StandardError => e
+          ::OneApm::Agent.logger.error("Failed ERB processing configuration file. This is typically caused by a Ruby error in <% %> templating blocks in your oneapm.yml file.", e)
+          nil
+        end
+      end
+
+      def process_yaml(file, env, config, path)
+        if file
+          confighash = with_yaml_engine { YAML.load(file) }
+          ::OneApm::Agent.logger.error("Config file at #{path} doesn't include a '#{env}' section!") unless confighash.key?(env)
+
+          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 OneApm::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
+    end
+  end
+end

data/lib/one_apm/errors/agent_errors.rb

@@ -0,0 +1,26 @@
+module OneApm
+    # An exception that is thrown by the server if the agent license is invalid.
+    class LicenseException < StandardError; end
+
+    # An exception that forces an agent to stop reporting until its mongrel is restarted.
+    class ForceDisconnectException < StandardError; end
+
+    # An exception that forces an agent to restart.
+    class ForceRestartException < StandardError; end
+
+    # Used to blow out of a periodic task without logging a an error, such as for routine
+    # failures.
+    class ServerConnectionException < StandardError; end
+
+    # When a post is either too large or poorly formatted we should
+    # drop it and not try to resend
+    class UnrecoverableServerException < ServerConnectionException; end
+
+    # An unrecoverable client-side error that prevents the agent from continuing
+    class UnrecoverableAgentException < ServerConnectionException; end
+
+    # An error while serializing data for the collector
+    class SerializationError < StandardError; end
+
+    class BackgroundLoadingError < StandardError; end
+end

data/lib/one_apm/errors/internal_agent_error.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+# This is the base class for all errors that we want to record through the
+# OneApm::Collector::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 OneApm
+  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/one_apm/errors/noticed_error.rb

@@ -0,0 +1,79 @@
+# encoding: utf-8
+
+require 'one_apm/support/helper'
+
+# This class encapsulates an error that was noticed by OneApm in a managed app.
+class OneApm::NoticedError
+  extend OneApm::CollectionHelper
+  include OneApm::Coerce
+
+  attr_accessor :path, :timestamp, :params, :message, :exception_class_name
+  attr_reader   :exception_id, :is_internal
+
+  STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE = "Message removed by OneApm 'strip_exception_messages' setting"
+
+  def initialize(path, data, exception, timestamp = Time.now)
+    @exception_id = exception.object_id
+    @path = path
+    @params = OneApm::NoticedError.normalize_params(data)
+
+    @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 < OneApm::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 OneApm::Agent.config[:'strip_exception_messages.enabled'] &&
+       !self.class.passes_message_whitelist(exception.class)
+      @message = STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE
+    end
+
+    @timestamp = timestamp
+  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)
+    OneApm::Agent.config.stripped_exceptions_whitelist.any? do |klass|
+      exception_class <= klass
+    end
+  end
+
+  def to_collector_array(encoder=nil)
+    [ OneApm::Helper.time_to_millis(timestamp),
+      string(path),
+      string(message),
+      string(exception_class_name),
+      params ]
+  end
+end