appoptics_apm 4.10.1 → 4.12.0

data/ext/oboe_metal/extconf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2016 SolarWinds, LLC.
 # All rights reserved.
 
@@ -20,7 +22,7 @@ ao_include = File.join(ext_dir, 'src')
 version = File.read(File.join(ao_include, 'VERSION')).chomp
 if ENV['APPOPTICS_FROM_S3'].to_s.downcase == 'true'
   ao_path = File.join('https://s3-us-west-2.amazonaws.com/rc-files-t2/c-lib/', version)
-  puts "Fetching c-lib from S3"
+  puts 'Fetching c-lib from S3'
 else
   ao_path = File.join('https://files.appoptics.com/c-lib', version)
 end
@@ -29,7 +31,7 @@ ao_arch = 'x86_64'
 if File.exist?('/etc/alpine-release')
   version = open('/etc/alpine-release').read.chomp
   ao_arch =
-    if Gem::Version.new(version) <  Gem::Version.new('3.9')
+    if Gem::Version.new(version) < Gem::Version.new('3.9')
       'alpine-libressl-x86_64'
     else # openssl
       'alpine-x86_64'
@@ -46,6 +48,8 @@ success = false
 while retries > 0
   begin
     # download
+    # TODO warning: calling URI.open via Kernel#open is deprecated, call URI.open directly or use URI#open
+    # ____ URI.open is not supported in 2.4.5, let's use open until we can deprecate 2.4.5
     download = open(ao_item, 'rb')
     IO.copy_stream(download, clib)
 

data/ext/oboe_metal/src/VERSION

@@ -1 +1 @@
-7.0.0
+10.0.0

data/ext/oboe_metal/src/function_profiler.hpp

@@ -0,0 +1,160 @@
+// function_profiler C++11 per-thread function profling
+// https://git.the-pluc.net/function_profiler.git/
+// Version 0.3
+//
+// Copyright (C) 2015, 2016 Pierre-Luc Perrier <pluc@the-pluc.net>
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef function_profiler_h
+#define function_profiler_h
+
+#ifdef FP_ENABLE
+
+#include <boost/chrono.hpp>
+
+#include <cstdio> // std::printf
+#include <ios>    // std::hex
+#include <string> // std::string
+#include <thread> // std::this_thread::get_id
+#include <iostream>
+#include <iomanip>
+
+namespace fp {
+
+// Main structure used to collect data
+struct collector {
+  // Clocks
+  using thread_clock = boost::chrono::thread_clock;
+  using thread_time_point = thread_clock::time_point;
+  using thread_accumulator = boost::chrono::duration<uint_least64_t, thread_clock::period>;
+
+  using steady_clock = boost::chrono::steady_clock;
+  using steady_time_point = steady_clock::time_point;
+  using steady_accumulator = boost::chrono::duration<uint_least64_t, steady_clock::period>;
+
+  // The duration we use for the report
+  using report_duration = boost::chrono::duration<double, boost::milli>;
+
+  collector() = delete;
+  collector(const std::string &name)
+    : m_thread_last{thread_clock::now()},
+      m_steady_last{steady_clock::now()},
+      m_count{0},
+      m_thread_accumulator{0},
+      m_steady_accumulator{0},
+      m_last_report{steady_clock::now()}
+  {
+    std::ostringstream os;
+    // os << "[FP] " << std::hex << std::this_thread::get_id() << " " << name << " #%-7lu %8.5F %8.5F %11.4F %11.4F\n";
+    os << std::setfill (' ') << std::setw(22) << name << "  " << std::hex << std::this_thread::get_id() << "\t#%-7lu\t%4.5F\t%4.5F\t%6.4F\t%6.4F\n";
+    m_fmt = os.str();
+  }
+
+  // We also report upon destruction. Note: this is probably a bad
+  // idea.
+  ~collector() noexcept
+  {
+    report();
+  }
+
+  inline void start() noexcept
+  {
+    m_thread_last = thread_clock::now();
+    m_steady_last = steady_clock::now();
+  }
+
+  inline void stop()
+  {
+    ++m_count;
+
+    {
+      const auto now = thread_clock::now();
+      m_thread_accumulator += now - m_thread_last;
+      m_thread_last = std::move(now);
+    }
+    {
+      const auto now = steady_clock::now();
+      m_steady_accumulator += now - m_steady_last;
+      m_steady_last = std::move(now);
+    }
+
+    // Check if we need to report current stats
+    if (m_steady_last - m_last_report > report_interval) {
+      m_last_report = m_steady_last;
+      report();
+    }
+  }
+
+private:
+  inline void report() const
+  {
+    if (m_count == 0) return;
+    const auto thread_ms = report_duration{m_thread_accumulator}.count();
+    const auto steady_ms = report_duration{m_steady_accumulator}.count();
+    std::printf(m_fmt.c_str(), m_count, steady_ms / m_count, thread_ms / m_count, steady_ms, thread_ms);
+  }
+
+private:
+  static constexpr auto report_interval = boost::chrono::seconds{1};
+
+  thread_time_point m_thread_last;         // Last thread clock time point
+  steady_time_point m_steady_last;         // Last steady clock time point
+  uint_least64_t m_count;                  // Number of samples
+  thread_accumulator m_thread_accumulator; // Total thread clock duration
+  steady_accumulator m_steady_accumulator; // Total steady clock duration
+  steady_time_point m_last_report;         // Last report
+  std::string m_fmt;                       // Format used for reporting
+};
+
+// RAII structure responsible to update a collector
+struct scoped_profiler {
+public:
+  scoped_profiler(collector &collector_) : m_collector{collector_}
+  {
+    m_collector.start();
+  }
+
+  ~scoped_profiler()
+  {
+    m_collector.stop();
+  }
+
+  scoped_profiler() = delete;
+  scoped_profiler(const scoped_profiler &) = delete;
+  scoped_profiler(scoped_profiler &&) = delete;
+
+  scoped_profiler &operator=(const scoped_profiler &) = delete;
+  scoped_profiler &operator=(scoped_profiler &&) = delete;
+
+private:
+  collector &m_collector;
+};
+
+// constexpr boost::chrono::seconds collector::report_interval;
+
+} // namespace fp
+
+// Note: __func__ is not a preprocessor macro, it's a 'function-local
+// predefined variable' (char *), hence we don't expand it.
+#define PROFILE_FUNCTION()                                                                                             \
+  thread_local fp::collector fp_info_fp{__func__};                                                                     \
+  fp::scoped_profiler fp_scoped_profiler_fp{fp_info_fp};
+
+#else // !FB_ENABLE
+
+#define PROFILE_FUNCTION() static_cast<void>(0);
+
+#endif // FB_ENABLE
+
+#endif // function_profiler_h

data/lib/appoptics_apm/api/logging.rb

@@ -55,7 +55,7 @@ module AppOpticsAPM
       # ==== Arguments
       #
       # * +layer+ - The layer the reported event belongs to
-      # * +exception+ - The exception to report
+      # * +exception+ - The exception to report, responds to :message and :backtrace(optional)
       # * +opts+ - Custom params if you want to log extra information
       #
       # ==== Example
@@ -80,7 +80,10 @@ module AppOpticsAPM
         opts.merge!(:Spec => 'error',
                     :ErrorClass => exception.class.name,
                     :ErrorMsg => exception.message)
-        opts.merge!(:Backtrace => exception.backtrace.join("\r\n")) if exception.backtrace
+
+        if exception.respond_to?(:backtrace) && exception.backtrace
+          opts.merge!(:Backtrace => exception.backtrace.join("\r\n"))
+        end
 
         exception.instance_variable_set(:@exn_logged, true)
         log(layer, :error, opts)
@@ -205,6 +208,7 @@ module AppOpticsAPM
       def log_info(layer, opts = {})
         return AppOpticsAPM::Context.toString unless AppOpticsAPM.tracing?
 
+        opts[:Spec] = 'info'
         log_event(layer, :info, AppOpticsAPM::Context.createEvent, opts)
       end
 

data/lib/appoptics_apm/api/metrics.rb

@@ -45,6 +45,8 @@ module  AppOpticsAPM
           AppOpticsAPM.transaction_name
         elsif kvs['Controller'] && kvs['Action']
           [kvs['Controller'], kvs['Action']].join('.')
+        elsif kvs[:Controller] && kvs[:Action]
+          [kvs[:Controller], kvs[:Action]].join('.')
         else
           "custom-#{span}"
         end
@@ -52,4 +54,4 @@ module  AppOpticsAPM
 
     end
   end
-end
+end

data/lib/appoptics_apm/api/util.rb

@@ -24,16 +24,14 @@ module AppOpticsAPM
 
       # Internal: Get the current backtrace.
       #
-      # ignore - Number of frames to ignore at the top of the backtrace. Use
-      #          when you know how many layers deep in the key call is being
-      #          made.
+      # from - int, from position in array of backtraces
+      # to - int, end position in array of backtraces, can be negative to count from the end
       #
       # Returns a string with each frame of the backtrace separated by '\r\n'.
       #
-      def backtrace(ignore = 0)
+      def backtrace(from = 0, to = -1)
         bt = Kernel.caller
-        bt.slice!(0, ignore)
-        trim_backtrace(bt).join("\r\n")
+        trim_backtrace(bt[from..to]).join("\r\n")
       end
 
       # Internal: Trim a backtrace to a manageable size
@@ -115,7 +113,7 @@ module AppOpticsAPM
       end
 
       def xtrace_v2?(xtr)
-        return xtr && xtr.start_with?('2B')
+        xtr && xtr.start_with?('2B')
       end
     end
   end

data/lib/appoptics_apm/config.rb

@@ -16,7 +16,7 @@ module AppOpticsAPM
     @@instrumentation = [:action_controller, :action_controller_api, :action_view,
                          :active_record, :bunnyclient, :bunnyconsumer, :cassandra, :curb,
                          :dalli, :delayed_jobclient, :delayed_jobworker,
-                         :excon, :faraday, :grpc_client, :grpc_server, :grape,
+                         :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]
@@ -65,15 +65,16 @@ module AppOpticsAPM
       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
-        AppOpticsAPM.logger.warn [
-          '[appoptics_apm/config] Multiple configuration files configured, using the first one listed: ',
-          config_files.join(', ')
-        ].join(' ')
+      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
-      load(config_files[0])
+
       # sets AppOpticsAPM::Config[:debug_level], AppOpticsAPM.logger.level
       set_log_level
 

data/lib/appoptics_apm/frameworks/grape.rb

@@ -53,7 +53,8 @@ module AppOpticsAPM
         end
 
         def error_response_with_appoptics(error = {})
-          status, headers, body = error_response_without_appoptics(error)
+          response = error_response_without_appoptics(error)
+          status, headers, _body = response.finish
 
           xtrace = AppOpticsAPM::Context.toString
 
@@ -77,7 +78,7 @@ module AppOpticsAPM
             end
           end
 
-          [status, headers, body]
+          response
         end
       end
     end

data/lib/appoptics_apm/frameworks/padrino.rb

@@ -58,7 +58,7 @@ module AppOpticsAPM
   end
 end
 
-if defined?(Padrino) && AppopticsAPM::Config[:padrino][:enabled]
+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]

data/lib/appoptics_apm/frameworks/rails.rb

@@ -1,6 +1,8 @@
 # Copyright (c) 2016 SolarWinds, LLC.
 # All rights reserved.
 
+require_relative '../../../lib/appoptics_apm/inst/logger_formatter'
+
 module AppOpticsAPM
   module Rails
     module Helpers
@@ -75,6 +77,10 @@ if defined?(::Rails)
         AppOpticsAPM::Rails.include_helpers
       end
 
+      initializer 'appoptics_apm.controller', before: 'wicked_pdf.register' do
+        AppOpticsAPM::Rails.load_instrumentation
+      end
+
       initializer 'appoptics_apm.rack' do |app|
         AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting rack' if AppOpticsAPM::Config[:verbose]
         app.config.middleware.insert 0, AppOpticsAPM::Rack
@@ -84,7 +90,7 @@ if defined?(::Rails)
         AppOpticsAPM.logger = ::Rails.logger if ::Rails.logger && !ENV.key?('APPOPTICS_GEM_TEST')
 
         AppOpticsAPM::Inst.load_instrumentation
-        AppOpticsAPM::Rails.load_instrumentation
+        # AppOpticsAPM::Rails.load_instrumentation
 
         # Report __Init after fork when in Heroku
         AppOpticsAPM::API.report_init unless AppOpticsAPM.heroku?

data/lib/appoptics_apm/frameworks/sinatra.rb

@@ -73,7 +73,7 @@ module AppOpticsAPM
   end
 end
 
-if defined?(Sinatra) && AppopticsAPM::Config[:sinatra][:enabled]
+if defined?(Sinatra) && AppOpticsAPM::Config[:sinatra][:enabled]
   require 'appoptics_apm/inst/rack'
 
   AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting Sinatra' if AppOpticsAPM::Config[:verbose]

data/lib/appoptics_apm/inst/graphql.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+#--
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+#++
+
+# initial version of this instrumentation:
+# https://github.com/librato/api/blob/master/graph/tracing/appoptics.rb
+#
+
+# TODO: make sure this stays up to date with
+# ____  what is in the graphql gem and vice-versa
+
+
+if defined?(GraphQL::Tracing) && !(AppOpticsAPM::Config[:graphql][:enabled] == false)
+  module GraphQL
+    module Tracing
+      # AppOpticsTracing in the graphql gem may be a different version than the
+      # one defined here, we want to use the newer one
+      redefine = true
+      this_version = Gem::Version.new('1.0.0')
+
+      if defined?(GraphQL::Tracing::AppOpticsTracing)
+        if this_version > GraphQL::Tracing::AppOpticsTracing.version
+          send(:remove_const, :AppOpticsTracing)
+        else
+          redefine = false
+        end
+      end
+
+      if redefine
+        #-----------------------------------------------------------------------------#
+        #----- this class is duplicated in the graphql gem ---------------------------#
+        #-----------------------------------------------------------------------------#
+        class AppOpticsTracing < GraphQL::Tracing::PlatformTracing
+          # These GraphQL events will show up as 'graphql.prep' spans
+          PREP_KEYS = ['lex', 'parse', 'validate', 'analyze_query', 'analyze_multiplex'].freeze
+          EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
+
+          # During auto-instrumentation this version of AppOpticsTracing is compared
+          # with the version provided in the graphql gem, so that the newer
+          # version of the class can be used
+
+          def self.version
+            Gem::Version.new('1.0.0')
+          end
+
+          self.platform_keys = {
+            'lex' => 'lex',
+            'parse' => 'parse',
+            'validate' => 'validate',
+            'analyze_query' => 'analyze_query',
+            'analyze_multiplex' => 'analyze_multiplex',
+            'execute_multiplex' => 'execute_multiplex',
+            'execute_query' => 'execute_query',
+            'execute_query_lazy' => 'execute_query_lazy'
+          }
+
+          def platform_trace(platform_key, _key, data)
+            return yield if !defined?(AppOpticsAPM) || gql_config[:enabled] == false
+
+            layer = span_name(platform_key)
+            kvs = metadata(data, layer)
+            kvs[:Key] = platform_key if (PREP_KEYS + EXEC_KEYS).include?(platform_key)
+
+            transaction_name(kvs[:InboundQuery]) if kvs[:InboundQuery] && layer == 'graphql.execute'
+
+            ::AppOpticsAPM::SDK.trace(layer, kvs) do
+              kvs.clear # we don't have to send them twice
+              yield
+            end
+          end
+
+          def platform_field_key(type, field)
+            "graphql.#{type.name}.#{field.name}"
+          end
+
+          private
+
+          def gql_config
+            ::AppOpticsAPM::Config[:graphql] ||= {}
+          end
+
+          def transaction_name(query)
+            return if gql_config[:transaction_name] == false ||
+              ::AppOpticsAPM::SDK.get_transaction_name
+
+            split_query = query.strip.split(/\W+/, 3)
+            split_query[0] = 'query' if split_query[0].empty?
+            name = "graphql.#{split_query[0..1].join('.')}"
+
+            ::AppOpticsAPM::SDK.set_transaction_name(name)
+          end
+
+          def multiplex_transaction_name(names)
+            return if gql_config[:transaction_name] == false ||
+              ::AppOpticsAPM::SDK.get_transaction_name
+
+            name = "graphql.multiplex.#{names.join('.')}"
+            name = "#{name[0..251]}..." if name.length > 254
+
+            ::AppOpticsAPM::SDK.set_transaction_name(name)
+          end
+
+          def span_name(key)
+            return 'graphql.prep' if PREP_KEYS.include?(key)
+            return 'graphql.execute' if EXEC_KEYS.include?(key)
+
+            key[/^graphql\./] ? key : "graphql.#{key}"
+          end
+
+          # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+          def metadata(data, layer)
+            data.keys.map do |key|
+              case key
+              when :context
+                graphql_context(data[key], layer)
+              when :query
+                graphql_query(data[key])
+              when :query_string
+                graphql_query_string(data[key])
+              when :multiplex
+                graphql_multiplex(data[key])
+              else
+                [key, data[key]]
+              end
+            end.flatten.each_slice(2).to_h.merge(Spec: 'graphql')
+          end
+          # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+          def graphql_context(context, layer)
+            context.errors && context.errors.each do |err|
+              AppOpticsAPM::API.log_exception(layer, err)
+            end
+
+            [[:Path, context.path.join('.')]]
+          end
+
+          def graphql_query(query)
+            return [] unless query
+
+            query_string = query.query_string
+            query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+            query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+            [[:InboundQuery, query_string],
+             [:Operation, query.selected_operation_name]]
+          end
+
+          def graphql_query_string(query_string)
+            query_string = remove_comments(query_string) if gql_config[:remove_comments] != false
+            query_string = sanitize(query_string) if gql_config[:sanitize_query] != false
+
+            [:InboundQuery, query_string]
+          end
+
+          def graphql_multiplex(data)
+            names = data.queries.map(&:operations).map(&:keys).flatten.compact
+            multiplex_transaction_name(names) if names.size > 1
+
+            [:Operations, names.join(', ')]
+          end
+
+          def sanitize(query)
+            return unless query
+
+            # remove arguments
+            query.gsub(/"[^"]*"/, '"?"')                 # strings
+              .gsub(/-?[0-9]*\.?[0-9]+e?[0-9]*/, '?') # ints + floats
+              .gsub(/\[[^\]]*\]/, '[?]')              # arrays
+          end
+
+          def remove_comments(query)
+            return unless query
+
+            query.gsub(/#[^\n\r]*/, '')
+          end
+        end
+        #-----------------------------------------------------------------------------#
+      end
+    end
+  end
+
+  module AppOpticsAPM
+    module GraphQLSchemaPrepend
+      def use(plugin, **options)
+        # super unless GraphQL::Schema.plugins.find { |pl| pl[0].to_s == plugin.to_s }
+        super unless self.plugins.find { |pl| pl[0].to_s == plugin.to_s }
+
+        self.plugins
+      end
+
+      def inherited(subclass)
+        subclass.use(GraphQL::Tracing::AppOpticsTracing)
+        super
+      end
+    end
+
+    # rubocop:disable Style/RedundantSelf
+    module GraphQLErrorPrepend
+      def initialize(*args)
+        super
+        bt = AppOpticsAPM::API.backtrace(1)
+        set_backtrace(bt) unless self.backtrace
+      end
+    end
+    # rubocop:enable Style/RedundantSelf
+
+    # a different way of autoinstrumenting for graphql 1.7.4 - < 1.8.0
+    module GraphQLSchemaPrepend17
+      def initialize
+        super
+        unless tracers.find { |tr| tr.is_a? GraphQL::Tracing::AppOpticsTracing }
+          tracer = GraphQL::Tracing::AppOpticsTracing.new
+          tracers.push(tracer)
+          instrumenters[:field] << tracer
+        end
+      end
+    end
+  end
+
+  if Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version >= Gem::Version.new('1.8.0')
+    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting GraphQL' if AppOpticsAPM::Config[:verbose]
+    if defined?(GraphQL::Schema)
+      GraphQL::Schema.singleton_class.prepend(AppOpticsAPM::GraphQLSchemaPrepend)
+    end
+
+    # rubocop:disable Style/IfUnlessModifier
+    if defined?(GraphQL::Error)
+      GraphQL::Error.prepend(AppOpticsAPM::GraphQLErrorPrepend)
+    end
+    # rubocop:enable Style/IfUnlessModifier
+  elsif Gem.loaded_specs['graphql'] && Gem.loaded_specs['graphql'].version >= Gem::Version.new('1.7.4')
+    AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting GraphQL' if AppOpticsAPM::Config[:verbose]
+    if defined?(GraphQL::Schema)
+      GraphQL::Schema.prepend(AppOpticsAPM::GraphQLSchemaPrepend17)
+    end
+  end
+end