appoptics_apm-zearn 4.13.1

data/lib/appoptics_apm/base.rb

@@ -0,0 +1,231 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+# Constants from liboboe
+APPOPTICS_TRACE_DISABLED   = 0
+APPOPTICS_TRACE_ENABLED  = 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
+
+##
+# 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 technicalsupport@solarwinds.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
+
+  # TODO ME review use of these boolean statements
+  # ____ they should now be handled by TransactionSettings,
+  # ____ because there can be exceptions to :enabled and :disabled
+
+  ##
+  # Returns true if the tracing_mode is set to :enabled.
+  # False otherwise
+  #
+  def tracing_enabled?
+    AppOpticsAPM::Config[:tracing_mode] &&
+      [:enabled, :always].include?(AppOpticsAPM::Config[:tracing_mode].to_sym)
+  end
+
+  ##
+  # Returns true if the tracing_mode is set to :disabled.
+  # False otherwise
+  #
+  def tracing_disabled?
+    AppOpticsAPM::Config[:tracing_mode] &&
+      [:disabled, :never].include?(AppOpticsAPM::Config[:tracing_mode].to_sym)
+  end
+
+  ##
+  # Returns true if we are currently tracing a request
+  # False otherwise
+  #
+  def tracing?
+    return false if !AppOpticsAPM.loaded # || AppOpticsAPM.tracing_disabled?
+    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,299 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require_relative 'support/transaction_settings'
+
+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,
+                         :excon, :faraday, :graphql, :grpc_client, :grpc_server, :grape,
+                         :httpclient, :nethttp, :memcached, :mongo, :moped, :padrino, :rack, :redis,
+                         :resqueclient, :resqueworker, :rest_client,
+                         :sequel, :sidekiqclient, :sidekiqworker, :sinatra, :typhoeus]
+
+    # ignore configs for instrumentations we don't have anymore
+    # can't remove because the config may still be present in configs created
+    # with previous gem versions
+    @@ignore = [:em_http_request]
+
+    # 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
+          AppOpticsAPM.logger.warn "[appoptics_apm/config] Could not find the configuration file set by the APPOPTICS_APM_CONFIG_RUBY environment variable:  #{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)
+
+      unless config_files.empty? # we use the defaults from the template if there are no config files
+        if config_files.size > 1
+          AppOpticsAPM.logger.warn [
+                                     '[appoptics_apm/config] Multiple configuration files configured, using the first one listed: ',
+                                     config_files.join(', ')
+                                   ].join(' ')
+        end
+        load(config_files[0])
+      end
+
+      # sets AppOpticsAPM::Config[:debug_level], AppOpticsAPM.logger.level
+      set_log_level
+
+      # 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
+
+    def self.set_log_level
+      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'] || AppOpticsAPM::Config[:debug_level] || 3).to_i
+      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
+      AppOpticsAPM::Config[:debug_level] = debug_level
+    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+@@ignore).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'))
+    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)
+      key = key.to_sym
+      @@config[key] = 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 == :dnt_regexp
+        if value.nil? || value == ''
+          @@config[:dnt_compiled] = nil
+        else
+          @@config[:dnt_compiled] =
+            Regexp.new(AppOpticsAPM::Config[:dnt_regexp], AppOpticsAPM::Config[:dnt_opts] || nil)
+        end
+
+      elsif key == :dnt_opts
+        if AppOpticsAPM::Config[:dnt_regexp] && AppOpticsAPM::Config[:dnt_regexp] != ''
+          @@config[:dnt_compiled] =
+            Regexp.new(AppOpticsAPM::Config[:dnt_regexp], AppOpticsAPM::Config[:dnt_opts] || nil)
+        end
+
+      elsif key == :profiling_interval
+        if value.is_a?(Integer) && value > 0
+          value = [100, value].min
+        else
+          value = 10
+        end
+        @@config[:profiling_interval] = value
+        # CProfiler may not be loaded yet, the profiler will send the value
+        # after it is loaded
+        AppOpticsAPM::CProfiler.set_interval(value) if defined? AppOpticsAPM::CProfiler
+
+      elsif key == :transaction_settings
+        if value.is_a?(Hash)
+          AppOpticsAPM::TransactionSettings.compile_url_settings(value[:url])
+        else
+          AppOpticsAPM::TransactionSettings.reset_url_regexps
+        end
+
+      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
+
+      elsif key == :tracing_mode
+      #   CAN'T DO `set_tracing_mode` ANYMORE, ALL TRACING COMMUNICATION TO OBOE
+      #   IS NOW HANDLED BY TransactionSettings
+      #   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
+
+      elsif key == :trigger_tracing_mode
+        # 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

data/lib/appoptics_apm/frameworks/grape.rb

@@ -0,0 +1,98 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+#
+class GrapeError < StandardError; end
+
+module AppOpticsAPM
+  module Grape
+    module API
+      def self.extended(klass)
+        AppOpticsAPM::Util.class_method_alias(klass, :inherited, ::Grape::API)
+      end
+
+      def inherited_with_appoptics(subclass)
+        inherited_without_appoptics(subclass)
+
+        subclass.use AppOpticsAPM::Rack
+      end
+    end
+
+    module Endpoint
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :run, ::Grape::Endpoint)
+      end
+
+      def run_with_appoptics(*args)
+        # Report Controller/Action and Transaction as best possible
+        report_kvs = {}
+
+        report_kvs[:Controller] = options[:for].to_s
+        report_kvs[:Action] =
+          if route&.pattern
+            route.options ? "#{route.options[:method]}#{route.pattern.origin}" : route.pattern.origin
+          else
+            args.empty? ? env['PATH_INFO'] : args[0]['PATH_INFO']
+          end
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:grape][:collect_backtraces]
+
+        env['appoptics_apm.controller'] = report_kvs[:Controller]
+        env['appoptics_apm.action']     = report_kvs[:Action]
+
+        AppOpticsAPM::API.log_entry('grape', report_kvs)
+
+        run_without_appoptics(*args)
+      ensure
+        AppOpticsAPM::API.log_exit('grape')
+      end
+    end
+
+    module Middleware
+      module Error
+        def self.included(klass)
+          AppOpticsAPM::Util.method_alias(klass, :error_response, ::Grape::Middleware::Error)
+        end
+
+        def error_response_with_appoptics(error = {})
+          response = error_response_without_appoptics(error)
+          status, headers, _body = response.finish
+
+          xtrace = AppOpticsAPM::Context.toString
+
+          if AppOpticsAPM.tracing?
+
+            # Since Grape uses throw/catch and not Exceptions, we have to create an exception here
+            exception = GrapeError.new(error[:message] ? error[:message] : "No message given.")
+            exception.set_backtrace(AppOpticsAPM::API.backtrace)
+
+            AppOpticsAPM::API.log_exception('rack', exception)
+
+            # Since calls to error() are handled similar to abort in Grape.  We
+            # manually log the rack exit here since the original code won't
+            # be returned to
+            xtrace = AppOpticsAPM::API.log_end('rack', :Status => status)
+          end
+
+          if headers && AppOpticsAPM::XTrace.valid?(xtrace)
+            unless defined?(JRUBY_VERSION) && AppOpticsAPM.is_continued_trace?
+              headers['X-Trace'] = xtrace if headers.is_a?(Hash)
+            end
+          end
+
+          response
+        end
+      end
+    end
+  end
+end
+
+if AppOpticsAPM::Config[:grape][:enabled] && defined?(Grape)
+  require 'appoptics_apm/inst/rack'
+
+  AppOpticsAPM.logger.info "[appoptics_apm/loading] Instrumenting Grape" if AppOpticsAPM::Config[:verbose]
+
+  AppOpticsAPM::Inst.load_instrumentation
+
+  AppOpticsAPM::Util.send_extend(Grape::API,                AppOpticsAPM::Grape::API)
+  AppOpticsAPM::Util.send_include(Grape::Endpoint,          AppOpticsAPM::Grape::Endpoint)
+  AppOpticsAPM::Util.send_include(Grape::Middleware::Error, AppOpticsAPM::Grape::Middleware::Error)
+end

data/lib/appoptics_apm/frameworks/padrino.rb

@@ -0,0 +1,78 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module PadrinoInst
+    module Routing
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :dispatch!, ::Padrino::Routing)
+      end
+
+      def dispatch_with_appoptics
+
+        AppOpticsAPM::API.log_entry('padrino', {})
+        report_kvs = {}
+
+        result = dispatch_without_appoptics
+
+        # Report Controller/Action and Transaction as best possible
+        controller = (request.controller && !request.controller.empty?) ? request.controller : nil
+        report_kvs[:Controller] = controller || self.class
+        report_kvs[:Action] = request.route_obj ? request.route_obj.path : request.action
+        env['appoptics_apm.controller'] = report_kvs[:Controller]
+        env['appoptics_apm.action']     = report_kvs[:Action]
+
+        result
+      rescue => e
+        AppOpticsAPM::API.log_exception('padrino', e)
+        raise e
+      ensure
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:padrino][:collect_backtraces]
+        AppOpticsAPM::API.log_exit('padrino', report_kvs)
+      end
+    end
+
+    module Rendering
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :render, ::Padrino::Rendering)
+      end
+
+      # TODO add test coverage, currently there are no tests for this
+      # ____ I'm not sure this gets ever called, Padrino uses Sinatra's render method
+      def render_with_appoptics(engine, data = nil, options = {}, locals = {}, &block)
+        if AppOpticsAPM.tracing?
+          report_kvs = {}
+
+          report_kvs[:engine] = engine
+          report_kvs[:template] = data
+
+          AppOpticsAPM::SDK.trace(:padrino_render, report_kvs, :padrino_render) do
+            report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:padrino][:collect_backtraces]
+            render_without_appoptics(engine, data, options, locals, &block)
+          end
+        else
+          render_without_appoptics(engine, data, options, locals, &block)
+        end
+      end
+    end
+  end
+end
+
+if defined?(Padrino) && AppOpticsAPM::Config[:padrino][:enabled]
+  # This instrumentation is a superset of the Sinatra instrumentation similar
+  # to how Padrino is a superset of Sinatra itself.
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting Padrino' if AppOpticsAPM::Config[:verbose]
+
+  Padrino.after_load do
+    AppOpticsAPM.logger = Padrino.logger if Padrino.respond_to?(:logger)
+    AppOpticsAPM::Inst.load_instrumentation
+
+    AppOpticsAPM::Util.send_include(Padrino::Routing::InstanceMethods, AppOpticsAPM::PadrinoInst::Routing)
+    if defined?(Padrino::Rendering)
+      AppOpticsAPM::Util.send_include(Padrino::Rendering::InstanceMethods, AppOpticsAPM::PadrinoInst::Rendering)
+    end
+
+    # Report __Init after fork when in Heroku
+    AppOpticsAPM::API.report_init unless AppOpticsAPM.heroku?
+  end
+end