appoptics_apm_mnfst 4.5.2

data/lib/appoptics_apm/base.rb

@@ -0,0 +1,230 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+# Constants from liboboe
+APPOPTICS_TRACE_NEVER   = 0
+APPOPTICS_TRACE_ALWAYS  = 1
+
+# OBOE_SAMPLE_RATE_SOURCE_FILE                   = 1
+# OBOE_SAMPLE_RATE_SOURCE_DEFAULT                = 2
+# OBOE_SAMPLE_RATE_SOURCE_OBOE                   = 3
+# OBOE_SAMPLE_RATE_SOURCE_LAST_OBOE              = 4
+# OBOE_SAMPLE_RATE_SOURCE_DEFAULT_MISCONFIGURED  = 5
+# OBOE_SAMPLE_RATE_SOURCE_OBOE_DEFAULT           = 6
+
+# Masks for bitwise ops
+# ZERO_MASK = 0b0000000000000000000000000000
+
+SAMPLE_RATE_MASK   = 0b0000111111111111111111111111
+SAMPLE_SOURCE_MASK = 0b1111000000000000000000000000
+
+# ZERO_SAMPLE_RATE_MASK   = 0b1111000000000000000000000000
+# ZERO_SAMPLE_SOURCE_MASK = 0b0000111111111111111111111111
+
+APPOPTICS_STR_BLANK = ''.freeze
+APPOPTICS_STR_LAYER = 'Layer'.freeze
+APPOPTICS_STR_LABEL = 'Label'.freeze
+
+# Used in tests to store local trace data
+TRACE_FILE = '/tmp/appoptics_traces.bson'.freeze
+
+##
+# This module is the base module for the various implementations of AppOpticsAPM reporting.
+# Current variations as of 2014-09-10 are a c-extension, JRuby (using AppOpticsAPM Java
+# instrumentation) and a Heroku c-extension (with embedded tracelyzer)
+module AppOpticsAPMBase
+  extend AppOpticsAPM::ThreadLocal
+
+  attr_accessor :reporter
+  attr_accessor :loaded
+  thread_local :sample_source
+  thread_local :sample_rate
+  thread_local :layer
+  thread_local :layer_op
+
+  # transaction_name is used for custom transaction naming
+  # It needs to be globally accessible, but is only set by the request processors of the different frameworks
+  # and read by rack
+  thread_local :transaction_name
+
+  # Semaphore used during the test suite to test
+  # global config options.
+  thread_local :config_lock
+
+  # The following accessors indicate the incoming tracing state received
+  # by the rack layer.  These are primarily used to identify state
+  # between the Ruby and JAppOpticsAPM instrumentation under JRuby.
+  #
+  # This is because that even though there may be an incoming
+  # X-Trace request header, tracing may have already been started
+  # by Joboe.  Such a scenario occurs when the application is being
+  # hosted by a Java container (such as Tomcat or Glassfish) and
+  # AppOpticsAPM has already initiated tracing.  In this case, we shouldn't
+  # pickup the X-Trace context in the X-Trace header and we shouldn't
+  # set the outgoing response X-Trace header or clear context.
+  # Yeah I know.  Yuck.
+
+  # Occurs only on Jruby.  Indicates that Joboe (the java instrumentation)
+  # has already started tracing before it hit the JRuby instrumentation.
+  # It is used in Rack#call if there is a context when entering rack
+  thread_local :has_incoming_context
+
+  # Indicates the existence of a valid X-Trace request header
+  thread_local :has_xtrace_header
+
+  # This indicates that this trace was continued from
+  # an incoming X-Trace request header or in the case
+  # of JRuby, a trace already started by JAppOpticsAPM.
+  thread_local :is_continued_trace
+
+  ##
+  # extended
+  #
+  # Invoked when this module is extended.
+  # e.g. extend AppOpticsAPMBase
+  #
+  def self.extended(cls)
+    cls.loaded = true
+
+    # This gives us pretty accessors with questions marks at the end
+    # e.g. is_continued_trace --> is_continued_trace?
+    AppOpticsAPM.methods.select { |m| m =~ /^is_|^has_/ }.each do |c|
+      unless c =~ /\?$|=$/
+        # AppOpticsAPM.logger.debug "aliasing #{c}? to #{c}"
+        alias_method "#{c}?", c
+      end
+    end
+  end
+
+  ##
+  # pickup_context
+  #
+  # for JRUBY
+  # Determines whether we should pickup context
+  # from an incoming X-Trace request header.  The answer
+  # is generally yes but there are cases in JRuby under
+  # Tomcat (or Glassfish etc.) where tracing may have
+  # been already started by the Java instrumentation (Joboe)
+  # in which case we don't want to do this.
+  #
+  def pickup_context?(xtrace)
+    return false unless AppOpticsAPM::XTrace.valid?(xtrace)
+
+    if defined?(JRUBY_VERSION) && AppOpticsAPM.tracing?
+      return false
+    else
+      return true
+    end
+  end
+
+  ##
+  # tracing_layer?
+  #
+  # Queries the thread local variable about the current
+  # layer being traced.  This is used in cases of recursive
+  # operation tracing or one instrumented operation calling another.
+  #
+  def tracing_layer?(layer)
+    AppOpticsAPM.layer == layer.to_sym
+  end
+
+  ##
+  # tracing_layer_op?
+  #
+  # Queries the thread local variable about the current
+  # operation being traced.  This is used in cases of recursive
+  # operation tracing or one instrumented operation calling another.
+  #
+  # In such cases, we only want to trace the outermost operation.
+  #
+  def tracing_layer_op?(operation)
+    unless AppOpticsAPM.layer_op.nil? || AppOpticsAPM.layer_op.is_a?(Array)
+      AppOpticsAPM.logger.error('[appopticsapm/logging] INTERNAL: layer_op should be nil or an array, please report to support@appoptics.com')
+      return false
+    end
+
+    return false if AppOpticsAPM.layer_op.nil? || AppOpticsAPM.layer_op.empty? || !operation.respond_to?(:to_sym)
+    AppOpticsAPM.layer_op.last == operation.to_sym
+  end
+
+  ##
+  # Returns true if the tracing_mode is set to always.
+  # False otherwise
+  #
+  def always?
+    AppOpticsAPM::Config[:tracing_mode] &&
+      AppOpticsAPM::Config[:tracing_mode].to_sym == :always
+  end
+
+  ##
+  # Returns true if the tracing_mode is set to never.
+  # False otherwise
+  #
+  def never?
+    AppOpticsAPM::Config[:tracing_mode] &&
+      AppOpticsAPM::Config[:tracing_mode].to_sym == :never
+  end
+
+  ##
+  # Returns true if we are currently tracing a request
+  # False otherwise
+  #
+  def tracing?
+    return false if !AppOpticsAPM.loaded || AppOpticsAPM.never?
+    AppOpticsAPM::Context.isSampled
+  end
+
+  def heroku?
+    ENV.key?('APPOPTICS_URL')
+  end
+
+  ##
+  # Determines if we are running under a forking webserver
+  #
+  def forking_webserver?
+    if (defined?(::Unicorn) && ($PROGRAM_NAME =~ /unicorn/i)) ||
+       (defined?(::Puma) && ($PROGRAM_NAME =~ /puma/i))
+      true
+    else
+      false
+    end
+  end
+
+  ##
+  # Indicates whether a supported framework is in use
+  # or not
+  #
+  def framework?
+    defined?(::Rails) || defined?(::Sinatra) || defined?(::Padrino) || defined?(::Grape)
+  end
+
+  ##
+  # These methods should be implemented by the descendants
+  # (Oboe_metal, JOboe_metal (JRuby), Heroku_metal)
+  #
+  def sample?(_opts = {})
+    fail 'sample? should be implemented by metal layer.'
+  end
+
+  def log(_layer, _label, _options = {})
+    fail 'log should be implemented by metal layer.'
+  end
+
+  def set_tracing_mode(_mode)
+    fail 'set_tracing_mode should be implemented by metal layer.'
+  end
+
+  def set_sample_rate(_rate)
+    fail 'set_sample_rate should be implemented by metal layer.'
+  end
+end
+
+module AppOpticsAPM
+  extend AppOpticsAPMBase
+end
+
+# Setup an alias so we don't bug users
+# about single letter capitalization
+AppopticsAPM = AppOpticsAPM
+AppOpticsApm = AppOpticsAPM
+AppopticsApm = AppOpticsAPM

data/lib/appoptics_apm/config.rb

@@ -0,0 +1,254 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  ##
+  # This module exposes a nested configuration hash that can be used to
+  # configure and/or modify the functionality of the appoptics_apm gem.
+  #
+  # Use AppOpticsAPM::Config.show to view the entire nested hash.
+  #
+  module Config
+    @@config = {}
+
+    @@instrumentation = [:action_controller, :action_controller_api, :action_view,
+                         :active_record, :bunnyclient, :bunnyconsumer, :cassandra, :curb,
+                         :dalli, :delayed_jobclient, :delayed_jobworker,
+                         :em_http_request, :excon, :faraday, :grpc_client, :grpc_server, :grape,
+                         :httpclient, :nethttp, :memcached, :mongo, :moped, :padrino, :rack, :redis,
+                         :resqueclient, :resqueworker, :rest_client,
+                         :sequel, :sidekiqclient, :sidekiqworker, :sinatra, :typhoeus]
+
+    # Subgrouping of instrumentation
+    @@http_clients = [:curb, :excon, :em_http_request, :faraday, :httpclient, :nethttp, :rest_client, :typhoeus]
+
+    ##
+    # load_config_file
+    #
+    # There are 3 possible locations for the config file:
+    # Rails default, ENV['APPOPTICS_APM_CONFIG_RUBY'], or the gem's default
+    #
+    # Hierarchie:
+    # 1 - Rails default: config/initializers/appoptics_apm.rb
+    #     (also loaded  by Rails, but we can't reliably determine if Rails is running)
+    # 2 - ENV['APPOPTICS_APM_CONFIG_RUBY']
+    # 3 - Gem default: <startup_dir>/appoptics_apm_config.rb
+    #
+    def self.load_config_file
+      config_files = []
+
+      # Check for the rails config file
+      config_file = File.join(Dir.pwd, 'config/initializers/appoptics_apm.rb')
+      config_files << config_file if File.exist?(config_file)
+
+      # Check for file set by env variable
+      if ENV.key?('APPOPTICS_APM_CONFIG_RUBY')
+        if File.exist?(ENV['APPOPTICS_APM_CONFIG_RUBY']) && !File.directory?(ENV['APPOPTICS_APM_CONFIG_RUBY'])
+          config_files << ENV['APPOPTICS_APM_CONFIG_RUBY']
+        elsif File.exist?(File.join(ENV['APPOPTICS_APM_CONFIG_RUBY'], 'appoptics_apm_config.rb'))
+          config_files << File.join(ENV['APPOPTICS_APM_CONFIG_RUBY'], 'appoptics_apm_config.rb')
+        else
+          $stderr.puts 'Could not find the configuration file set by the APPOPTICS_APM_CONFIG_RUBY environment variable:'
+          $stderr.puts "#{ENV['APPOPTICS_APM_CONFIG_RUBY']}"
+        end
+      end
+
+      # Check for default config file
+      config_file = File.join(Dir.pwd, 'appoptics_apm_config.rb')
+      config_files << config_file if File.exist?(config_file)
+
+      return if config_files.empty?  # we use the defaults from the template in this case
+
+      if config_files.size > 1
+        $stderr.puts 'Found multiple configuration files, using the first one listed:'
+        config_files.each { |path| $stderr.puts "  #{path}" }
+      end
+      load(config_files[0])
+      check_env_vars
+    end
+
+    # There are 4 variables that can be set in the config file or as env vars.
+    # Oboe will override vars passed in if it finds an environment variable
+    # :debug_level and :verbose need special consideration, because they are used in Ruby
+    def self.check_env_vars
+      unless (-1..6).include?(AppOpticsAPM::Config[:debug_level])
+        AppOpticsAPM::Config[:debug_level] = 3
+      end
+
+      # let's find and use the  equivalent debug level for ruby
+      debug_level = ENV['APPOPTICS_DEBUG_LEVEL'] ? ENV['APPOPTICS_DEBUG_LEVEL'].to_i : AppOpticsAPM::Config[:debug_level]
+      if debug_level < 0
+        # there should be no logging if APPOPTICS_DEBUG_LEVEL == -1
+        # In Ruby level 5 is UNKNOWN and it can log, but level 6 is quiet
+        AppOpticsAPM.logger.level = 6
+      else
+        AppOpticsAPM.logger.level = [4 - debug_level, 0].max
+      end
+
+      # the verbose setting is only relevant for ruby, ENV['APPOPTICS_GEM_VERBOSE'] overrides
+      if ENV.key?('APPOPTICS_GEM_VERBOSE')
+        AppOpticsAPM::Config[:verbose] = ENV['APPOPTICS_GEM_VERBOSE'].downcase == 'true'
+      end
+    end
+
+    ##
+    # print_config
+    #
+    # print configurations one per line
+    # to create an output similar to the content of the config file
+    #
+    def self.print_config
+      AppOpticsAPM.logger.warn "# General configurations"
+      non_instrumentation = @@config.keys - @@instrumentation
+      non_instrumentation.each do |config|
+        AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:#{config}] = #{@@config[config]}"
+      end
+
+      AppOpticsAPM.logger.warn "\n# Instrumentation specific configurations"
+      AppOpticsAPM.logger.warn "# Enabled/Disabled Instrumentation"
+      @@instrumentation.each do |config|
+        AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:#{config}][:enabled] = #{@@config[config][:enabled]}"
+      end
+
+      AppOpticsAPM.logger.warn "\n# Enabled/Disabled Backtrace Collection"
+      @@instrumentation.each do |config|
+        AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:#{config}][:collect_backtraces] = #{@@config[config][:collect_backtraces]}"
+      end
+
+      AppOpticsAPM.logger.warn "\n# Logging of outgoing HTTP query args"
+      @@instrumentation.each do |config|
+        AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:#{config}][:log_args] = #{@@config[config][:log_args] || false}"
+      end
+
+      AppOpticsAPM.logger.warn "\n# Bunny Controller and Action"
+      AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:bunnyconsumer][:controller] = #{@@config[:bunnyconsumer][:controller].inspect}"
+      AppOpticsAPM.logger.warn "AppOpticsAPM::Config[:bunnyconsumer][:action] = #{@@config[:bunnyconsumer][:action].inspect}"
+      nil
+    end
+
+    ##
+    # initialize
+    #
+    # Initializer method to set everything up with a default configuration.
+    # The defaults are read from the template configuration file.
+    #
+    # rubocop:disable Metrics/AbcSize
+    def self.initialize(_data = {})
+      @@instrumentation.each { |k| @@config[k] = {} }
+      @@config[:transaction_name] = {}
+
+      # Always load the template, it has all the keys and defaults defined,
+      # no guarantee of completeness in the user's config file
+      load(File.join(File.dirname(File.dirname(__FILE__)),
+                    'rails/generators/appoptics_apm/templates/appoptics_apm_initializer.rb'))
+
+      # to make sure we include the service_key if it is set as an ENV var
+      check_env_vars
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def self.update!(data)
+      data.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    def self.merge!(data)
+      update!(data)
+    end
+
+    def self.[](key)
+      if key == :resque
+        AppOpticsAPM.logger.warn '[appoptics_apm/warn] :resque config is deprecated.  It is now split into :resqueclient and :resqueworker.'
+        AppOpticsAPM.logger.warn "[appoptics_apm/warn] Called from #{Kernel.caller[0]}"
+      end
+
+      @@config[key.to_sym]
+    end
+
+    ##
+    # []=
+    #
+    # Config variable assignment method.  Here we validate and store the
+    # assigned value(s) and trigger any secondary action needed.
+    #
+    # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+    def self.[]=(key, value)
+      @@config[key.to_sym] = value
+
+      if key == :sampling_rate
+        AppOpticsAPM.logger.warn '[appoptics_apm/config] sampling_rate is not a supported setting for AppOpticsAPM::Config.  ' \
+                         'Please use :sample_rate.'
+
+      elsif key == :sample_rate
+        unless value.is_a?(Integer) || value.is_a?(Float)
+          AppOpticsAPM.logger.warn "[appoptics_apm/config] :sample_rate must be a number between 0 and 1000000 (1m) " \
+                                   "(provided: #{value}), corrected to 0"
+          value = 0
+        end
+
+        # Validate :sample_rate value
+        unless value.between?(0, 1e6)
+          value_1 = value
+          value = value_1 < 0 ? 0 : 1_000_000
+          AppOpticsAPM.logger.warn "[appoptics_apm/config] :sample_rate must be between 0 and 1000000 (1m) " \
+                                   "(provided: #{value_1}), corrected to #{value}"
+        end
+
+        # Assure value is an integer
+        @@config[key.to_sym] = value.to_i
+        AppOpticsAPM.set_sample_rate(value) if AppOpticsAPM.loaded
+
+      elsif key == :action_blacklist
+        AppOpticsAPM.logger.warn "[appoptics_apm/config] :action_blacklist has been deprecated and no longer functions."
+
+      elsif key == :resque
+        AppOpticsAPM.logger.warn "[appoptics_apm/config] :resque config is deprecated.  It is now split into :resqueclient and :resqueworker."
+        AppOpticsAPM.logger.warn "[appoptics_apm/config] Called from #{Kernel.caller[0]}"
+
+      elsif key == :include_url_query_params # DEPRECATED
+        # Obey the global flag and update all of the per instrumentation
+        # <tt>:log_args</tt> values.
+        @@config[:rack][:log_args] = value
+
+      elsif key == :include_remote_url_params # DEPRECATED
+        # Obey the global flag and update all of the per instrumentation
+        # <tt>:log_args</tt> values.
+        @@http_clients.each do |i|
+          @@config[i][:log_args] = value
+        end
+
+      # Update liboboe if updating :tracing_mode
+      elsif key == :tracing_mode
+        AppOpticsAPM.set_tracing_mode(value.to_sym) if AppOpticsAPM.loaded
+
+        # Make sure that the mode is stored as a symbol
+        @@config[key.to_sym] = value.to_sym
+      end
+    end
+    # rubocop:enable Metrics/AbcSize, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+    def self.method_missing(sym, *args)
+      class_var_name = "@@#{sym}"
+
+      if sym.to_s =~ /(.+)=$/
+        self[$1] = args.first
+      else
+        # Try part of the @@config hash first
+        if @@config.key?(sym)
+          self[sym]
+
+        # Then try as a class variable
+        elsif self.class_variable_defined?(class_var_name.to_sym)
+          self.class_eval(class_var_name)
+
+        # Congrats - You've won a brand new nil...
+        else
+          nil
+        end
+      end
+    end
+  end
+end
+
+AppOpticsAPM::Config.initialize