appoptics_apm-zearn 4.13.1

data/lib/appoptics_apm/inst/sidekiq-client.rb

@@ -0,0 +1,55 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  class SidekiqClient
+    def collect_kvs(args)
+      begin
+        # Attempt to collect up pertinent info.  If we hit something unexpected,
+        # keep calm and instrument on.
+
+        report_kvs = {}
+        worker_class, msg, queue, _ = args
+
+        report_kvs[:Spec]      = :pushq
+        report_kvs[:Flavor]    = :sidekiq
+        report_kvs[:Queue]     = queue
+        report_kvs[:Retry]     = msg['retry']
+        report_kvs[:JobName]   = msg['wrapped'] || worker_class
+        report_kvs[:MsgID]     = msg['jid']
+        report_kvs[:Args]      = msg['args'].to_s[0..1024] if AppOpticsAPM::Config[:sidekiqclient][:log_args]
+        report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:sidekiqclient][:collect_backtraces]
+      rescue => e
+        AppOpticsAPM.logger.warn "[appoptics_apm/sidekiq] Non-fatal error capturing KVs: #{e.message}"
+      end
+      report_kvs
+    end
+
+    def call(*args)
+      # args: 0: worker_class, 1: msg, 2: queue, 3: redis_pool
+      if AppOpticsAPM.tracing?
+        report_kvs = collect_kvs(args)
+        AppOpticsAPM::API.log_entry(:'sidekiq-client', report_kvs)
+        args[1]['SourceTrace'] = AppOpticsAPM::Context.toString
+      end
+
+      result = yield
+    rescue => e
+      AppOpticsAPM::API.log_exception(:'sidekiq-client', e, { :JobID => result['jid'] })
+      raise
+    ensure
+      AppOpticsAPM::API.log_exit(:'sidekiq-client', { :JobID => result['jid'] })
+    end
+  end
+end
+
+if defined?(Sidekiq) && AppOpticsAPM::Config[:sidekiqclient][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting sidekiq client' if AppOpticsAPM::Config[:verbose]
+
+  Sidekiq.configure_client do |config|
+    config.client_middleware do |chain|
+      AppOpticsAPM.logger.info '[appoptics_apm/loading] Adding Sidekiq client middleware' if AppOpticsAPM::Config[:verbose]
+      chain.add AppOpticsAPM::SidekiqClient
+    end
+  end
+end

data/lib/appoptics_apm/inst/sidekiq-worker.rb

@@ -0,0 +1,66 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  class SidekiqWorker
+    def collect_kvs(args)
+      begin
+        # Attempt to collect up pertinent info.  If we hit something unexpected,
+        # keep calm and instrument on.
+        report_kvs = {}
+        _worker, msg, queue = args
+
+        # Background Job Spec KVs
+        report_kvs[:Spec]       = :job
+        report_kvs[:Flavor]     = :sidekiq
+        report_kvs[:Queue]      = queue
+        report_kvs[:Retry]      = msg['retry']
+        report_kvs[:JobName]    = msg['wrapped'] || msg['class']
+        report_kvs[:MsgID]      = msg['jid']
+        report_kvs[:Args]       = msg['args'].to_s[0..1024] if AppOpticsAPM::Config[:sidekiqworker][:log_args]
+        report_kvs[:Backtrace]  = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:sidekiqworker][:collect_backtraces]
+
+        # Webserver Spec KVs
+        report_kvs[:'HTTP-Host'] = Socket.gethostname
+        report_kvs[:Controller] = "Sidekiq_#{queue}"
+        report_kvs[:Action] = msg['wrapped'] || msg['class']
+        report_kvs[:URL] = "/sidekiq/#{queue}/#{msg['wrapped'] || msg['class']}"
+      rescue => e
+        AppOpticsAPM.logger.warn "[appoptics_apm/sidekiq] Non-fatal error capturing KVs: #{e.message}"
+      end
+      report_kvs
+    end
+
+    def call(*args)
+      # args: 0: worker, 1: msg, 2: queue
+      report_kvs = collect_kvs(args)
+
+      # TODO remove completely once it is determined that this works without
+      # Something is happening across Celluloid threads where liboboe settings
+      # are being lost.  So we re-set the tracing mode to assure
+      # we sample as desired.  Setting the tracing mode will re-update
+      # the liboboe settings.
+      # AppOpticsAPM.set_tracing_mode(AppOpticsAPM::Config[:tracing_mode].to_sym)
+
+      # Continue the trace from the enqueue side?
+      if args[1].is_a?(Hash) && AppOpticsAPM::XTrace.valid?(args[1]['SourceTrace'])
+        report_kvs[:SourceTrace] = args[1]['SourceTrace']
+      end
+
+      AppOpticsAPM::SDK.start_trace(:'sidekiq-worker', nil, report_kvs) do
+        yield
+      end
+    end
+  end
+end
+
+if defined?(Sidekiq) && AppOpticsAPM::Config[:sidekiqworker][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting sidekiq worker' if AppOpticsAPM::Config[:verbose]
+
+  Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      AppOpticsAPM.logger.info '[appoptics_apm/loading] Adding Sidekiq worker middleware' if AppOpticsAPM::Config[:verbose]
+      chain.add AppOpticsAPM::SidekiqWorker
+    end
+  end
+end

data/lib/appoptics_apm/inst/twitter-cassandra.rb

@@ -0,0 +1,294 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  module Inst
+    module Cassandra
+      def extract_trace_details(op, column_family, keys, args, options = {})
+        report_kvs = {}
+
+        begin
+          report_kvs[:Op] = op.to_s
+          report_kvs[:Cf] = column_family.to_s if column_family
+          report_kvs[:Key] = keys.inspect if keys
+
+          # Open issue - how to handle multiple Cassandra servers
+          report_kvs[:RemoteHost], report_kvs[:RemotePort] = @servers.first.split(':')
+
+          report_kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:cassandra][:collect_backtraces]
+
+          if options.empty? && args.is_a?(Array)
+            options = args.last if args.last.is_a?(Hash)
+          end
+
+          unless options.empty?
+            [:start_key, :finish_key, :key_count, :batch_size, :columns, :count, :start,
+             :stop, :finish, :finished, :reversed, :consistency, :ttl].each do |k|
+              report_kvs[k.to_s.capitalize] = options[k] if options.key?(k)
+            end
+
+            if op == :get_indexed_slices
+              index_clause = columns_and_options[:index_clause] || {}
+              unless index_clause.empty?
+                [:column_name, :value, :comparison].each do |k|
+                  report_kvs[k.to_s.capitalize] = index_clause[k] if index_clause.key?(k)
+                end
+              end
+            end
+          end
+        rescue => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+        end
+
+        report_kvs
+      end
+
+      def insert_with_appoptics(column_family, key, hash, options = {})
+        return insert_without_appoptics(column_family, key, hash, options = {}) unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:insert, column_family, key, hash, options)
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+          insert_without_appoptics(column_family, key, hash, options = {})
+        end
+      end
+
+      def remove_with_appoptics(column_family, key, *columns_and_options)
+        args = [column_family, key] + columns_and_options
+
+        return send :remove_without_appoptics, *args unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:remove, column_family, key, columns_and_options)
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+          send :remove_without_appoptics, *args
+        end
+      end
+
+      def count_columns_with_appoptics(column_family, key, *columns_and_options)
+        args = [column_family, key] + columns_and_options
+
+        return send :count_columns_without_appoptics, *args unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:count_columns, column_family, key, columns_and_options)
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+          send :count_columns_without_appoptics, *args
+        end
+      end
+
+      def get_columns_with_appoptics(column_family, key, *columns_and_options)
+        args = [column_family, key] + columns_and_options
+
+        if AppOpticsAPM.tracing? && !AppOpticsAPM.tracing_layer_op?(:multi_get_columns)
+          report_kvs = extract_trace_details(:get_columns, column_family, key, columns_and_options)
+
+          AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+            send :get_columns_without_appoptics, *args
+          end
+        else
+          send :get_columns_without_appoptics, *args
+        end
+      end
+
+      def multi_get_columns_with_appoptics(column_family, key, *columns_and_options)
+        args = [column_family, key] + columns_and_options
+
+        return send :multi_get_columns_without_appoptics, *args unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:multi_get_columns, column_family, key, columns_and_options)
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs, :multi_get_columns) do
+          send :multi_get_columns_without_appoptics, *args
+        end
+      end
+
+      def get_with_appoptics(column_family, key, *columns_and_options)
+        args = [column_family, key] + columns_and_options
+
+        return send :get_without_appoptics, *args unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:get, column_family, key, columns_and_options)
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs, :get) do
+          send :get_without_appoptics, *args
+        end
+      end
+
+      def multi_get_with_appoptics(column_family, key, *columns_and_options)
+        args = [column_family, key] + columns_and_options
+
+        if AppOpticsAPM.tracing? && !AppOpticsAPM.tracing_layer_op?(:get)
+          report_kvs = extract_trace_details(:multi_get, column_family, key, columns_and_options)
+
+          AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+            send :multi_get_without_appoptics, *args
+          end
+        else
+          send :multi_get_without_appoptics, *args
+        end
+      end
+
+      def exists_with_appoptics?(column_family, key, *columns_and_options)
+        args = [column_family, key] + columns_and_options
+
+        return send :exists_without_appoptics?, *args unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:exists?, column_family, key, columns_and_options)
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+          send :exists_without_appoptics?, *args
+        end
+      end
+
+      def get_range_single_with_appoptics(column_family, options = {})
+        if AppOpticsAPM.tracing? && !AppOpticsAPM.tracing_layer_op?(:get_range_batch)
+          report_kvs = extract_trace_details(:get_range_single, column_family, nil, nil)
+
+          AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+            get_range_single_without_appoptics(column_family, options)
+          end
+        else
+          get_range_single_without_appoptics(column_family, options)
+        end
+      end
+
+      def get_range_batch_with_appoptics(column_family, options = {})
+        return get_range_batch_without_appoptics(column_family, options) unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:get_range_batch, column_family, nil, nil)
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs, :get_range_batch) do
+          get_range_batch_without_appoptics(column_family, options)
+        end
+      end
+
+      def get_indexed_slices_with_appoptics(column_family, index_clause, *columns_and_options)
+        args = [column_family, index_clause] + columns_and_options
+
+        return send :get_indexed_slices_without_appoptics, *args unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:get_indexed_slices, column_family, nil, columns_and_options)
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+          send :get_indexed_slices_without_appoptics, *args
+        end
+      end
+
+      def create_index_with_appoptics(keyspace, column_family, column_name, validation_class)
+        unless AppOpticsAPM.tracing?
+          return create_index_without_appoptics(keyspace, column_family, column_name, validation_class)
+        end
+
+        report_kvs = extract_trace_details(:create_index, column_family, nil, nil)
+        begin
+          report_kvs[:Keyspace] = keyspace.to_s
+          report_kvs[:Column_name] = column_name.to_s
+          report_kvs[:Validation_class] = validation_class.to_s
+        rescue => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+        end
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+          create_index_without_appoptics(keyspace, column_family, column_name, validation_class)
+        end
+      end
+
+      def drop_index_with_appoptics(keyspace, column_family, column_name)
+        return drop_index_without_appoptics(keyspace, column_family, column_name) unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:drop_index, column_family, nil, nil)
+        begin
+          report_kvs[:Keyspace] = keyspace.to_s
+          report_kvs[:Column_name] = column_name.to_s
+        rescue => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+        end
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+          drop_index_without_appoptics(keyspace, column_family, column_name)
+        end
+      end
+
+      def add_column_family_with_appoptics(cf_def)
+        return add_column_family_without_appoptics(cf_def) unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:add_column_family, nil, nil, nil)
+        begin
+          report_kvs[:Cf] = cf_def[:name] if cf_def.is_a?(Hash) && cf_def.key?(:name)
+        rescue => e
+          AppOpticsAPM.logger.debug "[appoptics_apm/debug] #{__method__}:#{File.basename(__FILE__)}:#{__LINE__}: #{e.message}" if AppOpticsAPM::Config[:verbose]
+        end
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+          add_column_family_without_appoptics(cf_def)
+        end
+      end
+
+      def drop_column_family_with_appoptics(column_family)
+        return drop_column_family_without_appoptics(column_family) unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:drop_column_family, column_family, nil, nil)
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+          drop_column_family_without_appoptics(column_family)
+        end
+      end
+
+      def add_keyspace_with_appoptics(ks_def)
+        return add_keyspace_without_appoptics(ks_def) unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:add_keyspace, nil, nil, nil)
+        report_kvs[:Name] = ks_def.name rescue ''
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+          add_keyspace_without_appoptics(ks_def)
+        end
+      end
+
+      def drop_keyspace_with_appoptics(keyspace)
+        return drop_keyspace_without_appoptics(keyspace) unless AppOpticsAPM.tracing?
+
+        report_kvs = extract_trace_details(:drop_keyspace, nil, nil, nil)
+        report_kvs[:Name] = keyspace.to_s rescue ''
+
+        AppOpticsAPM::API.trace(:cassandra, report_kvs) do
+          drop_keyspace_without_appoptics(keyspace)
+        end
+      end
+    end
+  end
+end
+
+# There are two main Cassandra clients for Ruby.  This one from Twitter
+# and the other from datastax.  This one defined Cassandra as a class
+# and datastax defines it as a module.  We use this to detect
+# and differentiate between the client in use.
+
+if defined?(Cassandra) && Cassandra.is_a?(Class) && AppOpticsAPM::Config[:cassandra][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting cassandra' if AppOpticsAPM::Config[:verbose]
+
+  class Cassandra
+    include AppOpticsAPM::Inst::Cassandra
+
+    [:insert, :remove, :count_columns, :get_columns, :multi_get_columns, :get,
+     :multi_get, :get_range_single, :get_range_batch, :get_indexed_slices,
+     :create_index, :drop_index, :add_column_family, :drop_column_family,
+     :add_keyspace, :drop_keyspace].each do |m|
+      if method_defined?(m)
+        class_eval "alias #{m}_without_appoptics #{m}"
+        class_eval "alias #{m} #{m}_with_appoptics"
+      else AppOpticsAPM.logger.warn "[appoptics_apm/loading] Couldn't properly instrument Cassandra (#{m}).  Partial traces may occur."
+      end
+    end
+
+    # Special case handler for question mark methods
+    if method_defined?(:exists?)
+      alias exists_without_appoptics? exists?
+      alias exists? exists_with_appoptics?
+    else AppOpticsAPM.logger.warn '[appoptics_apm/loading] Couldn\'t properly instrument Cassandra (exists?).  Partial traces may occur.'
+    end
+  end # class Cassandra
+end
+
+

data/lib/appoptics_apm/inst/typhoeus.rb

@@ -0,0 +1,108 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+class TyphoeusError < StandardError; end
+
+module AppOpticsAPM
+  module Inst
+    module TyphoeusRequestOps
+
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :run, ::Typhoeus::Request::Operations)
+      end
+
+      def run_with_appoptics
+        blacklisted = AppOpticsAPM::API.blacklisted?(url)
+        unless AppOpticsAPM.tracing?
+          context = AppOpticsAPM::Context.toString
+          options[:headers]['X-Trace'] = context if AppOpticsAPM::XTrace.valid?(context) && !blacklisted
+          return run_without_appoptics
+        end
+
+        begin
+          AppOpticsAPM::API.log_entry(:typhoeus)
+
+          # Prepare X-Trace header handling
+          context = AppOpticsAPM::Context.toString
+          options[:headers]['X-Trace'] = context unless blacklisted
+
+          kvs = {}
+          kvs[:Spec] = 'rsc'
+          kvs[:IsService] = 1
+          kvs[:HTTPMethod] = AppOpticsAPM::Util.upcase(options[:method])
+
+          response = run_without_appoptics
+
+          # Re-attach edge unless it's blacklisted
+          # or if we don't have a valid X-Trace header
+          unless blacklisted
+            xtrace = response.headers['X-Trace']
+            AppOpticsAPM::XTrace.continue_service_context(context, xtrace)
+          end
+
+          if response.code == 0
+            exception = TyphoeusError.new(response.return_message)
+            exception.set_backtrace(AppOpticsAPM::API.backtrace)
+            AppOpticsAPM::API.log_exception(:typhoeus, exception)
+          end
+
+          kvs[:HTTPStatus] = response.code
+          kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:typhoeus][:collect_backtraces]
+          # Conditionally log query params
+          uri = URI(response.effective_url)
+          kvs[:RemoteURL] = AppOpticsAPM::Config[:typhoeus][:log_args] ? uri.to_s : uri.to_s.split('?').first
+          kvs[:Blacklisted] = true if blacklisted
+
+          response
+        rescue => e
+          AppOpticsAPM::API.log_exception(:typhoeus, e)
+          raise e
+        ensure
+          AppOpticsAPM::API.log_exit(:typhoeus, kvs)
+        end
+      end
+    end
+
+    module TyphoeusHydraRunnable
+      def self.included(klass)
+        AppOpticsAPM::Util.method_alias(klass, :run, ::Typhoeus::Hydra)
+      end
+
+      def run_with_appoptics
+        unless AppOpticsAPM.tracing?
+          context = AppOpticsAPM::Context.toString
+          queued_requests.map do |request|
+            blacklisted = AppOpticsAPM::API.blacklisted?(request.base_url)
+            request.options[:headers]['X-Trace'] = context if AppOpticsAPM::XTrace.valid?(context) && !blacklisted
+          end
+          return run_without_appoptics
+        end
+
+        kvs = {}
+
+        kvs[:queued_requests] = queued_requests.count
+        kvs[:max_concurrency] = max_concurrency
+        kvs[:Async] = 1
+        kvs[:Backtrace] = AppOpticsAPM::API.backtrace if AppOpticsAPM::Config[:typhoeus][:collect_backtraces]
+
+        # FIXME: Until we figure out a strategy to deal with libcurl internal
+        # threading and Ethon's use of easy handles, here we just do a simple
+        # trace of the hydra run.
+        AppOpticsAPM::API.trace(:typhoeus_hydra, kvs) do
+          queued_requests.map do |request|
+            blacklisted = AppOpticsAPM::API.blacklisted?(request.base_url)
+            request.options[:headers]['X-Trace'] = AppOpticsAPM::Context.toString unless blacklisted
+          end
+
+          run_without_appoptics
+        end
+      end
+    end
+
+  end
+end
+
+if defined?(Typhoeus) && AppOpticsAPM::Config[:typhoeus][:enabled]
+  AppOpticsAPM.logger.info '[appoptics_apm/loading] Instrumenting typhoeus' if AppOpticsAPM::Config[:verbose]
+  AppOpticsAPM::Util.send_include(Typhoeus::Request::Operations, AppOpticsAPM::Inst::TyphoeusRequestOps)
+  AppOpticsAPM::Util.send_include(Typhoeus::Hydra, AppOpticsAPM::Inst::TyphoeusHydraRunnable)
+end

data/lib/appoptics_apm/instrumentation.rb

@@ -0,0 +1,22 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module AppOpticsAPM
+  ##
+  # The Inst module holds all of the instrumentation extensions for various
+  # libraries such as Redis, Dalli and Resque.
+  module Inst
+    def self.load_instrumentation
+      # Load the general instrumentation
+      pattern = File.join(File.dirname(__FILE__), 'inst', '*.rb')
+      Dir.glob(pattern) do |f|
+        begin
+          require f
+        rescue => e
+          AppOpticsAPM.logger.error "[appoptics_apm/loading] Error loading instrumentation file '#{f}' : #{e}"
+          AppOpticsAPM.logger.debug "[appoptics_apm/loading] #{e.backtrace.first}"
+        end
+      end
+    end
+  end
+end

data/lib/appoptics_apm/loading.rb

@@ -0,0 +1,65 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'digest/sha1'
+
+module AppOpticsAPM
+  module Util
+    ##
+    # This module was used solely for the deprecated RUM ID calculation
+    # but may be useful in the future.
+    #
+    module Base64URL
+      module_function
+
+      def encode(bin)
+        c = [bin].pack('m0').gsub(/\=+\Z/, '').tr('+/', '-_').rstrip
+        m = c.size % 4
+        c += '=' * (4 - m) if m != 0
+        c
+      end
+
+      def decode(bin)
+        m = bin.size % 4
+        bin += '=' * (4 - m) if m != 0
+        bin.tr('-_', '+/').unpack('m0').first
+      end
+    end
+  end
+
+  ##
+  # This module houses all of the loading functionality for the appoptics_apm em.
+
+  # Note that this does not necessarily _have_ to include initialization routines
+  # (although it can).
+  #
+  # Actual initialization is often separated out as it can be dependent on on the state
+  # of the stack boot process.  e.g. code requiring that initializers, frameworks or
+  # instrumented libraries are already loaded...
+  #
+  module Loading
+    ##
+    # Load the appoptics_apm tracing API
+    #
+    def self.require_api
+      pattern = File.join(File.dirname(__FILE__), 'api', '*.rb')
+      Dir.glob(pattern) do |f|
+        require f
+      end
+
+      begin
+        require 'appoptics_apm/api'
+      rescue LoadError => e
+        AppOpticsAPM.logger.fatal "[appoptics_apm/error] Couldn't load api: #{e.message}"
+      end
+    end
+  end
+end
+
+AppOpticsAPM::Loading.require_api
+
+# Auto-start the Reporter unless we are running Unicorn on Heroku
+# In that case, we start the reporters after fork
+unless AppOpticsAPM.heroku? && AppOpticsAPM.forking_webserver?
+  AppOpticsAPM::Reporter.start if AppOpticsAPM.loaded
+end

data/lib/appoptics_apm/logger.rb

@@ -0,0 +1,14 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'logger'
+
+module AppOpticsAPM
+  class << self
+    attr_accessor :logger
+  end
+end
+
+AppOpticsAPM.logger = Logger.new(STDERR)
+# set log level to INFO to be consistent with the c-lib, DEBUG would be default
+AppOpticsAPM.logger.level = Logger::INFO

data/lib/appoptics_apm/noop/README.md

@@ -0,0 +1,9 @@
+Here we can define modules and classes for noop mode.
+
+Instead of polluting code with AppOpticsAPM.loaded conditionals
+
+we load these classes when in noop mode and they expose noop behavior.
+
+so far only one class is needed:
+
+- AppOpticsAPM::Context  and its toString() method from oboe

data/lib/appoptics_apm/noop/context.rb

@@ -0,0 +1,27 @@
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+
+####
+# noop version of AppOpticsAPM::Context
+#
+#
+
+module AppOpticsAPM
+  module Context
+
+    ##
+    # noop version of :toString
+    # toString would return the current context (xtrace) as string
+    #
+    def self.toString
+      '2B0000000000000000000000000000000000000000000000000000000000'
+    end
+
+    ##
+    # noop version of :clear
+    #
+    def self.clear
+
+    end
+  end
+end

data/lib/appoptics_apm/noop/metadata.rb

@@ -0,0 +1,25 @@
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+
+####
+# noop version of AppOpticsAPM::Metadata
+#
+#
+
+module AppOpticsAPM
+  class Metadata
+
+    ##
+    # noop version of :makeRandom
+    #
+    # needs to return an object that responds to :isValid
+    #
+    def self.makeRandom
+      Metadata.new
+    end
+
+    def isValid
+      false
+    end
+  end
+end