appoptics_apm 4.8.2 → 4.10.1

data/build_gem.sh

@@ -1,15 +0,0 @@
-#!/usr/bin/env bash
-# builds the appoptics_apm gem for MRI.
-
-# we currently only build for MRI, no JRuby
-echo -e "\n=== building for MRI ===\n"
-rm -f Gemfile.lock
-bundle install
-bundle exec rake distclean
-bundle exec rake fetch_ext_deps
-gem build appoptics_apm.gemspec
-
-echo -e "\n=== built gems ===\n"
-ls -la appoptics_apm*.gem
-
-echo -e "\n=== publish to rubygems via: gem push <gem> ===\n"

data/build_gem_upload_to_packagecloud.sh

@@ -1,20 +0,0 @@
-#!/bin/bash
-
-# build the gem,
-# oboe/c-lib version can be given as optional parameter
-if [ "$1" != "" ]; then
-  OBOE_VERSION=$1 ./build_gem.sh
-else
-  ./build_gem.sh
-fi
-
-# save current rbenv setting and switch to 2.4.1 for the package_cloud commands
-current_ruby=`rbenv global`
-rbenv global 2.4.1
-
-# prerequisite: package_cloud token needs to be in ~/.packagecloud
-gem=`ls -dt1 appoptics_apm-[^pre]*.gem | head -1`
-package_cloud push solarwinds/appoptics-apm-ruby $gem
-
-# restore ruby version
-rbenv global $current_ruby

data/lib/appoptics_apm/api/profiling.rb

@@ -1,203 +0,0 @@
-#--
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-#++
-
-module AppOpticsAPM
-  module API
-    ##
-    # Module to create profiling traces for blocks of code or methods
-    module Profiling
-      ##
-      # Public: Profile a given block of code. Detect any exceptions thrown by
-      # the block and report errors.
-      #
-      # ==== Arguments
-      #
-      # * +profile_name+ - A name used to identify the block being profiled.
-      # * +report_kvs+ - A hash containing key/value pairs that will be reported along
-      #   with the event of this profile (optional).
-      # * +with_backtrace+ - Boolean to indicate whether a backtrace should
-      #   be collected with this trace event.
-      #
-      # ==== Example
-      #
-      #   def computation(n)
-      #     AppOpticsAPM::API.profile('fib', { :n => n }) do
-      #       fib(n)
-      #     end
-      #   end
-      #
-      # Returns the result of the block.
-      #
-
-      def profile(profile_name, report_kvs = {}, with_backtrace = false)
-        return yield unless AppOpticsAPM.tracing?
-
-        begin
-          report_kvs[:Language] ||= :ruby
-          report_kvs[:ProfileName] ||= profile_name
-          report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if with_backtrace
-
-          AppOpticsAPM::API.log(nil, :profile_entry, report_kvs)
-
-          begin
-            yield
-          rescue => e
-            log_exception(nil, e)
-            raise
-          ensure
-            exit_kvs = {}
-            exit_kvs[:Language] = :ruby
-            exit_kvs[:ProfileName] = report_kvs[:ProfileName]
-
-            AppOpticsAPM::API.log(nil, :profile_exit, exit_kvs)
-          end
-        end
-      end
-
-      ##
-      # Public: Add profiling to a method on a class or module.  That method can be of any (accessible)
-      # type (instance, singleton, private, protected etc.).
-      #
-      # ==== Arguments
-      #
-      # * +klass+  - the class or module that has the method to profile
-      # * +method+ - the method to profile.  Can be singleton, instance, private etc...
-      # * +opts+   - a hash specifying the one or more of the following options:
-      #   * +:arguments+  - report the arguments passed to <tt>method</tt> on each profile (default: false)
-      #   * +:result+     - report the return value of <tt>method</tt> on each profile (default: false)
-      #   * +:backtrace+  - report the return value of <tt>method</tt> on each profile (default: false)
-      #   * +:name+       - alternate name for the profile reported in the dashboard (default: method name)
-      # * +extra_kvs+ - a hash containing any additional key/value pairs you would like reported with the profile
-      #
-      # ==== Example
-      #
-      #   opts = {}
-      #   opts[:backtrace] = true
-      #   opts[:arguments] = false
-      #   opts[:name] = :array_sort
-      #
-      #   AppOpticsAPM::API.profile_method(Array, :sort, opts)
-      #
-      def profile_method(klass, method, opts = {}, extra_kvs = {})
-        # If we're on an unsupported platform (ahem Mac), just act
-        # like we did something to nicely play the no-op part.
-        return true unless AppOpticsAPM.loaded
-
-        if !klass.is_a?(Module)
-          AppOpticsAPM.logger.warn "[appoptics_apm/error] profile_method: Not sure what to do with #{klass}.  Send a class or module."
-          return false
-        end
-
-        if method.is_a?(String)
-          method = method.to_sym
-        elsif !method.is_a?(Symbol)
-          AppOpticsAPM.logger.warn "[appoptics_apm/error] profile_method: Not sure what to do with #{method}.  Send a string or symbol for method."
-          return false
-        end
-
-        instance_method = klass.instance_methods.include?(method) || klass.private_instance_methods.include?(method)
-        class_method = klass.singleton_methods.include?(method)
-
-        # Make sure the request klass::method exists
-        if !instance_method && !class_method
-          AppOpticsAPM.logger.warn "[appoptics_apm/error] profile_method: Can't instrument #{klass}.#{method} as it doesn't seem to exist."
-          AppOpticsAPM.logger.warn "[appoptics_apm/error] #{__FILE__}:#{__LINE__}"
-          return false
-        end
-
-        # Strip '!' or '?' from method if present
-        safe_method_name = method.to_s.chop if method.to_s =~ /\?$|\!$/
-        safe_method_name ||= method
-
-        without_appoptics = "#{safe_method_name}_without_appoptics"
-        with_appoptics    = "#{safe_method_name}_with_appoptics"
-
-        # Check if already profiled
-        if klass.instance_methods.include?(with_appoptics.to_sym) ||
-           klass.singleton_methods.include?(with_appoptics.to_sym)
-          AppOpticsAPM.logger.warn "[appoptics_apm/error] profile_method: #{klass}::#{method} already profiled."
-          AppOpticsAPM.logger.warn "[appoptics_apm/error] profile_method: #{__FILE__}:#{__LINE__}"
-          return false
-        end
-
-        source_location = []
-        if instance_method
-          AppOpticsAPM::Util.send_include(klass, AppOpticsAPM::MethodProfiling)
-          source_location = klass.instance_method(method).source_location
-        elsif class_method
-          AppOpticsAPM::Util.send_extend(klass, AppOpticsAPM::MethodProfiling)
-          source_location = klass.method(method).source_location
-        end
-
-        report_kvs = collect_profile_kvs(klass, method, opts, extra_kvs, source_location)
-        report_kvs[:MethodName] = safe_method_name
-
-        if instance_method
-          klass.class_eval do
-            define_method(with_appoptics) do |*args, &block|
-              profile_wrapper(without_appoptics, report_kvs, opts, *args, &block)
-            end
-
-            alias_method without_appoptics, method.to_s
-            alias_method method.to_s, with_appoptics
-          end
-        elsif class_method
-          klass.define_singleton_method(with_appoptics) do |*args, &block|
-            profile_wrapper(without_appoptics, report_kvs, opts, *args, &block)
-          end
-
-          klass.singleton_class.class_eval do
-            alias_method without_appoptics, method.to_s
-            alias_method method.to_s, with_appoptics
-          end
-        end
-        true
-      end
-
-      private
-
-      ##
-      # Private: Helper method to aggregate KVs to report
-      #
-      # klass  - the class or module that has the method to profile
-      # method - the method to profile.  Can be singleton, instance, private etc...
-      # opts   - a hash specifying the one or more of the following options:
-      #   * :arguments  - report the arguments passed to <tt>method</tt> on each profile (default: false)
-      #   * :result     - report the return value of <tt>method</tt> on each profile (default: false)
-      #   * :backtrace  - report the return value of <tt>method</tt> on each profile (default: false)
-      #   * :name       - alternate name for the profile reported in the dashboard (default: method name)
-      # extra_kvs - a hash containing any additional KVs you would like reported with the profile
-      # source_location - array returned from klass.method(:name).source_location
-      #
-      def collect_profile_kvs(klass, method, opts, extra_kvs, source_location)
-        report_kvs = {}
-        report_kvs[:Language] ||= :ruby
-        report_kvs[:ProfileName] ||= opts[:name] ? opts[:name] : method
-
-        klass.is_a?(Class) ? report_kvs[:Class] = klass.to_s : report_kvs[:Module] = klass.to_s
-
-        # If this is a Rails Controller, report the KVs
-        if defined?(::AbstractController::Base) && klass.ancestors.include?(::AbstractController::Base)
-          report_kvs[:Controller] = klass.to_s
-          report_kvs[:Action] = method.to_s
-        end
-
-        # We won't have access to this info for native methods (those not defined in Ruby).
-        if source_location.is_a?(Array) && source_location.length == 2
-          report_kvs[:File] = source_location[0]
-          report_kvs[:LineNumber] = source_location[1]
-        end
-
-        # Merge in any extra_kvs requested
-        report_kvs.merge!(extra_kvs)
-      end
-
-
-      # need to set the context to public, otherwise the following `extends` will be private in api.rb
-      public
-
-    end
-  end
-end

data/lib/appoptics_apm/frameworks/rails/inst/action_controller3.rb

@@ -1,55 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-module AppOpticsAPM
-  module Inst
-    #
-    # ActionController
-    #
-    # This modules contains the instrumentation code specific
-    # to Rails v3
-    #
-    module ActionController
-      include AppOpticsAPM::Inst::RailsBase
-
-      def self.included(base)
-        base.class_eval do
-          alias_method_chain :process, :appoptics
-          alias_method_chain :process_action, :appoptics
-          alias_method_chain :render, :appoptics
-        end
-      end
-
-      def process_with_appoptics(*args)
-        request.env['appoptics_apm.controller'] = self.class.name
-        request.env['appoptics_apm.action'] = self.action_name
-
-        trace('rails') do
-          process_without_appoptics(*args)
-        end
-      end
-
-      def process_action_with_appoptics(*args)
-        kvs = {
-            :Controller   => self.class.name,
-            :Action       => action_name,
-        }
-        request.env['appoptics_apm.controller'] = kvs[:Controller]
-        request.env['appoptics_apm.action'] = kvs[:Action]
-
-        return process_action_without_appoptics(*args) unless AppOpticsAPM.tracing?
-        begin
-          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:action_controller][:collect_backtraces]
-          AppOpticsAPM::API.log(nil, 'info', kvs)
-
-          process_action_without_appoptics(*args)
-        rescue Exception
-          kvs[:Status] = 500
-          kvs.delete(:Backtrace)
-          AppOpticsAPM::API.log(nil, 'info', kvs)
-          raise
-        end
-      end
-    end
-  end
-end

data/lib/appoptics_apm/frameworks/rails/inst/action_view_30.rb

@@ -1,50 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-if defined?(ActionView::Base) && AppOpticsAPM::Config[:action_view][:enabled]
-
-  if Rails::VERSION::MAJOR == 3 && Rails::VERSION::MINOR == 0
-
-    ActionView::Partials::PartialRenderer.class_eval do
-      alias :render_partial_without_appoptics :render_partial
-      def render_partial(object = @object)
-        entry_kvs = {}
-        begin
-          name  = AppOpticsAPM::Util.prettify(@options[:partial]) if @options.is_a?(Hash)
-          entry_kvs[:FunctionName] = :render_partial
-          entry_kvs[:Class]        = :PartialRenderer
-          entry_kvs[:Module]       = 'ActionView::Partials'
-          entry_kvs[:File]         = __FILE__
-          entry_kvs[:LineNumber]   = __LINE__
-        rescue => e
-          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
-        end
-
-        AppOpticsAPM::API.profile(name, entry_kvs, AppOpticsAPM::Config[:action_view][:collect_backtraces]) do
-          render_partial_without_appoptics(object)
-        end
-      end
-
-      alias :render_collection_without_appoptics :render_collection
-      def render_collection
-        entry_kvs = {}
-        begin
-          name  = AppOpticsAPM::Util.prettify(@path)
-          entry_kvs[:FunctionName] = :render_collection
-          entry_kvs[:Class]        = :PartialRenderer
-          entry_kvs[:Module]       = 'ActionView::Partials'
-          entry_kvs[:File]         = __FILE__
-          entry_kvs[:LineNumber]   = __LINE__
-        rescue => e
-          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
-        end
-
-        AppOpticsAPM::API.profile(name, entry_kvs, AppOpticsAPM::Config[:action_view][:collect_backtraces]) do
-          render_collection_without_appoptics
-        end
-      end
-    end
-  end
-end
-
-# vim:set expandtab:tabstop=2

data/lib/appoptics_apm/legacy_method_profiling.rb

@@ -1,90 +0,0 @@
-# Copyright (c) 2016 SolarWinds, LLC.
-# All rights reserved.
-
-##
-# Provides the methods necessary for method profiling.  Profiling
-# results are sent to the AppOptics dashboard.
-#
-# Example usage:
-# class MyApp
-#   include AppOpticsAPMMethodProfiling
-#
-#   def process_request()
-#     # The hard work
-#   end
-#
-#   # call syntax: profile_method <method>, <profile_name>
-#   profile_method :process_request, 'request_processor'
-# end
-module AppOpticsAPMMethodProfiling
-  def self.included(klass)
-    klass.extend ClassMethods
-  end
-
-  module ClassMethods
-    def profile_method_noop(*args)
-      nil
-    end
-
-    def profile_method_real(method_name, profile_name, store_args = false, store_return = false, *_)
-      begin
-        # this only gets file and line where profiling is turned on, presumably
-        # right after the function definition.
-        file = ''
-        line = ''
-        info = instance_method(method_name).source_location
-        unless info.nil?
-          file = info[0].to_s
-          line = info[1].to_s
-        end
-
-        # Safety:  Make sure there are no quotes or double quotes to break the class_eval
-        file = file.gsub(/[\'\"]/, '')
-        line = line.gsub(/[\'\"]/, '')
-
-        # profiling via ruby-prof, is it possible to get return value of profiled code?
-        code = "def _appoptics_profiled_#{method_name}(*args, &block)
-                  entry_kvs                  = {}
-                  entry_kvs['Language']      = 'ruby'
-                  entry_kvs['ProfileName']   = '#{AppOpticsAPM::Util.prettify(profile_name)}'
-                  entry_kvs['FunctionName']  = '#{AppOpticsAPM::Util.prettify(method_name)}'
-                  entry_kvs['File']          = '#{file}'
-                  entry_kvs['LineNumber']    = '#{line}'
-                  entry_kvs['Args']          = AppOpticsAPM::API.pps(*args) if #{store_args}
-                  entry_kvs.merge!(AppOpticsAPM::API.get_class_name(self))
-
-                  AppOpticsAPM::API.log(nil, 'profile_entry', entry_kvs)
-
-                  ret = _appoptics_orig_#{method_name}(*args, &block)
-
-                  exit_kvs =  {}
-                  exit_kvs['Language'] = 'ruby'
-                  exit_kvs['ProfileName'] = '#{AppOpticsAPM::Util.prettify(profile_name)}'
-                  exit_kvs['ReturnValue'] = AppOpticsAPM::API.pps(ret) if #{store_return}
-
-                  AppOpticsAPM::API.log(nil, 'profile_exit', exit_kvs)
-                  ret
-                end"
-      rescue => e
-        AppOpticsAPM.logger.warn "[appoptics_apm/warn] profile_method: #{e.inspect}"
-      end
-
-      begin
-        class_eval code, __FILE__, __LINE__
-        alias_method "_appoptics_orig_#{method_name}", method_name
-        alias_method method_name, "_appoptics_profiled_#{method_name}"
-      rescue => e
-        AppOpticsAPM.logger.warn "[appoptics_apm/warn] Fatal error profiling method (#{method_name}): #{e.inspect}" if AppOpticsAPM::Config[:verbose]
-      end
-    end
-
-    # This allows this module to be included and called even if the gem is in
-    # no-op mode (no base libraries).
-    if AppOpticsAPM.loaded
-      alias :profile_method :profile_method_real
-    else
-      alias :profile_method :profile_method_noop
-    end
-
-  end
-end

data/lib/appoptics_apm/method_profiling.rb

@@ -1,33 +0,0 @@
-
-module AppOpticsAPM
-  module MethodProfiling
-    def profile_wrapper(method, report_kvs, opts, *args, &block)
-      report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace(2) if opts[:backtrace]
-      report_kvs[:Arguments] = args if opts[:arguments]
-
-      # if this is a rails controller we want to set the transaction for the outbound metrics
-      if defined?(request) && defined?(request.env)
-        report_kvs['Controller'] = self.class.name
-        report_kvs['Action'] = self.action_name
-        request.env['appoptics_apm.controller'] = report_kvs['Controller']
-        request.env['appoptics_apm.action'] = report_kvs['Action']
-      end
-
-      AppOpticsAPM::API.log(nil, :profile_entry, report_kvs)
-
-      begin
-        rv = self.send(method, *args, &block)
-        report_kvs[:ReturnValue] = rv if opts[:result]
-        rv
-      rescue => e
-        AppOpticsAPM::API.log_exception(nil, e)
-        raise
-      ensure
-        report_kvs.delete(:Backtrace)
-        report_kvs.delete(:Controller)
-        report_kvs.delete(:Action)
-        AppOpticsAPM::API.log(nil, :profile_exit, report_kvs)
-      end
-    end
-  end
-end