solarwinds_apm 5.0.0

data/lib/solarwinds_apm/inst/sequel.rb

@@ -0,0 +1,241 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  module Inst
+    ##
+    # SolarWindsAPM::Inst::Sequel
+    #
+    # The common (shared) methods used by the SolarWindsAPM Sequel instrumentation
+    # across multiple modules/classes.
+    #
+    module Sequel
+      ##
+      # assign_kvs
+      #
+      # Given SQL and the options hash, this method extracts the interesting
+      # bits for reporting to the SolarWinds dashboard.
+      #
+      # kvs is a hash and we are taking advantage of using it by reference to
+      # assign kvs to the exit event (important for trace injection)
+      #
+      def assign_kvs(sql, opts, kvs)
+        unless sql.is_a?(String)
+          kvs[:IsPreparedStatement] = true
+        end
+
+        if ::Sequel::VERSION > '4.36.0' && !sql.is_a?(String)
+          # TODO check if this is true for all sql
+          # In 4.37.0, sql was converted to a prepared statement object
+          sql = sql.prepared_sql unless sql.is_a?(Symbol)
+        end
+
+        if SolarWindsAPM::Config[:sanitize_sql]
+          # Sanitize SQL and don't report binds
+          if sql.is_a?(Symbol)
+            kvs[:Query] = sql
+          else
+            sql = SolarWindsAPM::Util.remove_traceparent(sql)
+            kvs[:Query] = SolarWindsAPM::Util.sanitize_sql(sql)
+          end
+        else
+          # Report raw SQL and any binds if they exist
+          kvs[:Query] = SolarWindsAPM::Util.remove_traceparent(sql.to_s)
+          kvs[:QueryArgs] = opts[:arguments] if opts.is_a?(Hash) && opts.key?(:arguments)
+        end
+
+        kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:sequel][:collect_backtraces]
+
+        if ::Sequel::VERSION < '3.41.0' && !(self.class.to_s =~ /Dataset$/)
+          db_opts = @opts
+        elsif @pool
+          db_opts = @pool.db.opts
+        else
+          db_opts = @db.opts
+        end
+
+        kvs[:Database]   = db_opts[:database]
+        kvs[:RemoteHost] = db_opts[:host]
+        kvs[:RemotePort] = db_opts[:port] if db_opts.key?(:port)
+        kvs[:Flavor]     = db_opts[:adapter]
+      rescue => e
+        SolarWindsAPM.logger.debug "[solarwinds_apm/debug Error capturing Sequel KVs: #{e.message}" if SolarWindsAPM::Config[:verbose]
+      end
+
+      ##
+      # exec_with_sw_apm
+      #
+      # This method wraps and routes the call to the specified
+      # original method call
+      #
+      def exec_with_sw_apm(method, sql, opts = ::Sequel::OPTS, &block)
+        kvs = {}
+        SolarWindsAPM::SDK.trace(:sequel, kvs: kvs) do
+          new_sql = add_traceparent(sql, kvs)
+          assign_kvs(new_sql, opts, kvs) if SolarWindsAPM.tracing?
+          send(method, new_sql, opts, &block)
+        end
+      end
+
+      def add_traceparent(sql, kvs)
+        return sql unless SolarWindsAPM.tracing? && SolarWindsAPM::Config[:tag_sql]
+
+        case sql
+        when String
+          return SolarWindsAPM::SDK.current_trace_info.add_traceparent_to_sql(sql, kvs)
+        when Symbol
+          if defined?(prepared_statement) # for mysql2
+            ps = prepared_statement(sql)
+            new_ps = add_traceparent_to_ps(ps, kvs)
+            set_prepared_statement(sql, new_ps)
+            return sql # related query may have been modified
+          elsif self.is_a?(::Sequel::Dataset) # for postgresql
+            ps = self
+            new_ps = add_traceparent_to_ps(ps, kvs)
+            self.db.set_prepared_statement(sql, new_ps)
+            return sql
+          end
+        when ::Sequel::Dataset::ArgumentMapper # for mysql2
+          new_sql = add_traceparent_to_ps(sql, kvs)
+          return new_sql # related query may have been modified
+        end
+        sql # return original when none of the cases match
+      end
+
+      # this method uses some non-api methods partially copied from
+      # `execute_prepared_statement` in `mysql2.rb`
+      # and `prepare` in `prepared_statements.rb` in the sequel gem
+      def add_traceparent_to_ps(ps, kvs)
+        sql = ps.prepared_sql
+        new_sql = SolarWindsAPM::SDK.current_trace_info.add_traceparent_to_sql(sql, kvs)
+
+        unless new_sql == sql
+          new_ps = ps.clone(:prepared_sql=>new_sql, :sql=>new_sql)
+          return new_ps
+        end
+
+        ps # no change, no trace context added
+      end
+    end
+
+    module SequelDatabase
+      include SolarWindsAPM::Inst::Sequel
+
+      def self.included(klass)
+        SolarWindsAPM::Util.method_alias(klass, :run, ::Sequel::Database)
+        SolarWindsAPM::Util.method_alias(klass, :execute_ddl, ::Sequel::Database)
+        SolarWindsAPM::Util.method_alias(klass, :execute_dui, ::Sequel::Database)
+        SolarWindsAPM::Util.method_alias(klass, :execute_insert, ::Sequel::Database)
+      end
+
+      def run_with_sw_apm(sql, opts = ::Sequel::OPTS)
+        kvs = {}
+        SolarWindsAPM::SDK.trace(:sequel, kvs: kvs) do
+          new_sql = add_traceparent(sql, kvs)
+          assign_kvs(new_sql, opts, kvs) if SolarWindsAPM.tracing?
+          run_without_sw_apm(new_sql, opts)
+        end
+      end
+
+      def execute_ddl_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
+        # If we're already tracing a sequel operation, then this call likely came
+        # from Sequel::Dataset.  In this case, just pass it on.
+        return execute_ddl_without_sw_apm(sql, opts, &block) if SolarWindsAPM.tracing_layer?(:sequel)
+
+        exec_with_sw_apm(:execute_ddl_without_sw_apm, sql, opts, &block)
+      end
+
+      def execute_dui_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
+        # If we're already tracing a sequel operation, then this call likely came
+        # from Sequel::Dataset.  In this case, just pass it on.
+        return execute_dui_without_sw_apm(sql, opts, &block) if SolarWindsAPM.tracing_layer?(:sequel)
+
+        exec_with_sw_apm(:execute_dui_without_sw_apm, sql, opts, &block)
+      end
+
+      def execute_insert_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
+        # If we're already tracing a sequel operation, then this call likely came
+        # from Sequel::Dataset.  In this case, just pass it on.
+        return execute_insert_without_sw_apm(sql, opts, &block) if SolarWindsAPM.tracing_layer?(:sequel)
+
+        exec_with_sw_apm(:execute_insert_without_sw_apm, sql, opts, &block)
+      end
+    end # module SequelDatabase
+
+    module AdapterDatabase
+      include SolarWindsAPM::Inst::Sequel
+
+      def self.included(klass)
+        if defined?(::Sequel::MySQL::MysqlMysql2::DatabaseMethods)
+          SolarWindsAPM::Util.method_alias(klass, :execute, ::Sequel::MySQL::MysqlMysql2::DatabaseMethods)
+        end
+        if defined?(::Sequel::Postgres::Database)
+          SolarWindsAPM::Util.method_alias(klass, :execute, ::Sequel::Postgres::Database)
+        end
+      end
+
+      def execute_with_sw_apm(*args, &block)
+        # if this is called via a dataset it is already being traced
+        return execute_without_sw_apm(*args, &block) if SolarWindsAPM.tracing_layer?(:sequel)
+
+        kvs = {}
+        SolarWindsAPM::SDK.trace(:sequel, kvs: kvs) do
+          new_sql = add_traceparent(args[0], kvs)
+          args[0] = new_sql
+          assign_kvs(args[0], args[1], kvs) if SolarWindsAPM.tracing?
+          execute_without_sw_apm(*args, &block)
+        end
+      end
+    end
+
+    module SequelDataset
+      include SolarWindsAPM::Inst::Sequel
+
+      def self.included(klass)
+        SolarWindsAPM::Util.method_alias(klass, :execute, ::Sequel::Dataset)
+        SolarWindsAPM::Util.method_alias(klass, :execute_ddl, ::Sequel::Dataset)
+        SolarWindsAPM::Util.method_alias(klass, :execute_dui, ::Sequel::Dataset)
+        SolarWindsAPM::Util.method_alias(klass, :execute_insert, ::Sequel::Dataset)
+      end
+
+      def execute_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
+        exec_with_sw_apm(:execute_without_sw_apm, sql, opts, &block)
+      end
+
+      def execute_ddl_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
+        exec_with_sw_apm(:execute_ddl_without_sw_apm, sql, opts, &block)
+      end
+
+      def execute_dui_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
+        exec_with_sw_apm(:execute_dui_without_sw_apm, sql, opts, &block)
+      end
+
+      def execute_insert_with_sw_apm(sql, opts = ::Sequel::OPTS, &block)
+        exec_with_sw_apm(:execute_insert_without_sw_apm, sql, opts, &block)
+      end
+
+    end # module SequelDataset
+  end # module Inst
+end # module SolarWindsAPM
+
+if SolarWindsAPM::Config[:sequel][:enabled]
+  if defined?(::Sequel) && ::Sequel::VERSION < '4.0.0'
+    # For versions before 4.0.0, Sequel::OPTS wasn't defined.
+    # Define it as an empty hash for backwards compatibility.
+    module ::Sequel
+      OPTS = {}
+    end
+  end
+
+  if defined?(::Sequel)
+    SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting sequel' if SolarWindsAPM::Config[:verbose]
+    SolarWindsAPM::Util.send_include(::Sequel::Database, SolarWindsAPM::Inst::SequelDatabase)
+    SolarWindsAPM::Util.send_include(::Sequel::Dataset, SolarWindsAPM::Inst::SequelDataset)
+
+    # TODO this is temporary, we need to instrument `require`, see NH-9711
+    require 'sequel/adapters/mysql2'
+    SolarWindsAPM::Util.send_include(::Sequel::MySQL::MysqlMysql2::DatabaseMethods, SolarWindsAPM::Inst::AdapterDatabase)
+    require 'sequel/adapters/postgres'
+    SolarWindsAPM::Util.send_include(::Sequel::Postgres::Database, SolarWindsAPM::Inst::AdapterDatabase)
+  end
+end

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

@@ -0,0 +1,63 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  class SidekiqClient
+    include SolarWindsAPM::SDK::TraceContextHeaders
+
+    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 SolarWindsAPM::Config[:sidekiqclient][:log_args]
+        report_kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:sidekiqclient][:collect_backtraces]
+      rescue => e
+        SolarWindsAPM.logger.warn "[solarwinds_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 SolarWindsAPM.tracing?
+        report_kvs = collect_kvs(args)
+        SolarWindsAPM::API.log_entry(:'sidekiq-client', report_kvs)
+        if args[1].is_a?(Hash)
+          # We've been doing this since 2015, but ...
+          # ... is it actually safe to inject our entries into the msg of the job?
+          # Opentelemetry does it too :), so I guess we're good
+          args[1]['SourceTrace'] = SolarWindsAPM::Context.toString
+          add_tracecontext_headers(args[1])
+        end
+      end
+
+      result = yield
+    rescue => e
+      SolarWindsAPM::API.log_exception(:'sidekiq-client', e, { :JobID => result['jid'] })
+      raise
+    ensure
+      SolarWindsAPM::API.log_exit(:'sidekiq-client', { :JobID => result['jid'] })
+    end
+  end
+end
+
+if defined?(Sidekiq) && SolarWindsAPM::Config[:sidekiqclient][:enabled]
+  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting sidekiq client' if SolarWindsAPM::Config[:verbose]
+
+  Sidekiq.configure_client do |config|
+    config.client_middleware do |chain|
+      SolarWindsAPM.logger.info '[solarwinds_apm/loading] Adding Sidekiq client middleware' if SolarWindsAPM::Config[:verbose]
+      chain.add SolarWindsAPM::SidekiqClient
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  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 SolarWindsAPM::Config[:sidekiqworker][:log_args]
+        report_kvs[:Backtrace]  = SolarWindsAPM::API.backtrace if SolarWindsAPM::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
+        SolarWindsAPM.logger.warn "[solarwinds_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)
+
+      # Continue the trace from the enqueue side
+      if args[1].is_a?(Hash) && SolarWindsAPM::TraceString.valid?(args[1]['SourceTrace'])
+        report_kvs[:SourceTrace] = args[1]['SourceTrace']
+        SolarWindsAPM::Context.fromString(args[1]['SourceTrace'])
+        args[1].delete('SourceTrace')
+        unless args[1]['traceparent'] && args[1]['tracestate']
+          add_tracecontext_headers(args[1])
+        end
+      end
+
+      SolarWindsAPM::SDK.start_trace(:'sidekiq-worker', kvs: report_kvs, headers: args[1]) do
+        yield
+      end
+    end
+  end
+end
+
+if defined?(Sidekiq) && SolarWindsAPM::Config[:sidekiqworker][:enabled]
+  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting sidekiq worker' if SolarWindsAPM::Config[:verbose]
+
+  Sidekiq.configure_server do |config|
+    config.server_middleware do |chain|
+      SolarWindsAPM.logger.info '[solarwinds_apm/loading] Adding Sidekiq worker middleware' if SolarWindsAPM::Config[:verbose]
+      chain.add SolarWindsAPM::SidekiqWorker
+    end
+  end
+end

data/lib/solarwinds_apm/inst/typhoeus.rb

@@ -0,0 +1,90 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+class TyphoeusError < StandardError; end
+
+module SolarWindsAPM
+  module Inst
+    module TyphoeusRequestOps
+      include SolarWindsAPM::SDK::TraceContextHeaders
+
+      def run
+        unless SolarWindsAPM.tracing?
+          add_tracecontext_headers(options[:headers])
+          return super
+        end
+
+        begin
+          SolarWindsAPM::API.log_entry(:typhoeus)
+
+          context = SolarWindsAPM::Context.toString
+
+          kvs = {}
+          kvs[:Spec] = 'rsc'
+          kvs[:IsService] = 1
+          kvs[:HTTPMethod] = SolarWindsAPM::Util.upcase(options[:method])
+
+          add_tracecontext_headers(options[:headers])
+          response = super
+
+          if response.code == 0
+            exception = TyphoeusError.new(response.return_message)
+            exception.set_backtrace(SolarWindsAPM::API.backtrace)
+            SolarWindsAPM::API.log_exception(:typhoeus, exception)
+          end
+
+          kvs[:HTTPStatus] = response.code
+          kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::Config[:typhoeus][:collect_backtraces]
+          # Conditionally log query params
+          uri = URI(response.effective_url)
+          kvs[:RemoteURL] = SolarWindsAPM::Config[:typhoeus][:log_args] ? uri.to_s : uri.to_s.split('?').first
+
+          response
+        rescue => e
+          SolarWindsAPM::API.log_exception(:typhoeus, e)
+          raise e
+        ensure
+          SolarWindsAPM::API.log_exit(:typhoeus, kvs)
+        end
+      end
+    end
+
+    module TyphoeusHydraRunnable
+      include SolarWindsAPM::SDK::TraceContextHeaders
+
+      def run
+        unless SolarWindsAPM.tracing?
+          queued_requests.map do |request|
+            add_tracecontext_headers(request.options[:headers])
+          end
+          return super
+        end
+
+        kvs = {}
+
+        kvs[:queued_requests] = queued_requests.count
+        kvs[:max_concurrency] = max_concurrency
+        kvs[:Async] = 1
+        kvs[:Backtrace] = SolarWindsAPM::API.backtrace if SolarWindsAPM::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.
+        SolarWindsAPM::SDK.trace(:typhoeus_hydra, kvs: kvs) do
+          queued_requests.map do |request|
+            add_tracecontext_headers(request.options[:headers])
+          end
+
+          super
+        end
+      end
+    end
+
+  end
+end
+
+if defined?(Typhoeus) && SolarWindsAPM::Config[:typhoeus][:enabled]
+  SolarWindsAPM.logger.info '[solarwinds_apm/loading] Instrumenting typhoeus' if SolarWindsAPM::Config[:verbose]
+
+  Typhoeus::Request.prepend(SolarWindsAPM::Inst::TyphoeusRequestOps)
+  Typhoeus::Hydra.prepend(SolarWindsAPM::Inst::TyphoeusHydraRunnable)
+end

data/lib/solarwinds_apm/instrumentation.rb

@@ -0,0 +1,22 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+module SolarWindsAPM
+  ##
+  # 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
+          SolarWindsAPM.logger.error "[solarwinds_apm/loading] Error loading instrumentation file '#{f}' : #{e}"
+          SolarWindsAPM.logger.debug "[solarwinds_apm/loading] #{e.backtrace.first}"
+        end
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/loading.rb

@@ -0,0 +1,65 @@
+# Copyright (c) 2016 SolarWinds, LLC.
+# All rights reserved.
+
+require 'digest/sha1'
+
+module SolarWindsAPM
+  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 solarwinds_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 solarwinds_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 'solarwinds_apm/api'
+      rescue LoadError => e
+        SolarWindsAPM.logger.fatal "[solarwinds_apm/error] Couldn't load api: #{e.message}"
+      end
+    end
+  end
+end
+
+SolarWindsAPM::Loading.require_api
+
+# Auto-start the Reporter unless we are running Unicorn on Heroku
+# In that case, we start the reporters after fork
+unless SolarWindsAPM.heroku? && SolarWindsAPM.forking_webserver?
+  SolarWindsAPM::Reporter.start if SolarWindsAPM.loaded
+end

data/lib/solarwinds_apm/logger.rb

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

data/lib/solarwinds_apm/noop/README.md

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

data/lib/solarwinds_apm/noop/context.rb

@@ -0,0 +1,26 @@
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+
+####
+# noop version of SolarWindsAPM::Context
+#
+#
+
+module SolarWindsAPM
+  module Context
+
+    ##
+    # noop version of :toString
+    # toString would return the current trace context as string
+    #
+    def self.toString
+      '00-00000000000000000000000000000000-0000000000000000-00'
+    end
+
+    ##
+    # noop version of :clear
+    #
+    def self.clear
+    end
+  end
+end

data/lib/solarwinds_apm/noop/metadata.rb

@@ -0,0 +1,25 @@
+# Copyright (c) 2019 SolarWinds, LLC.
+# All rights reserved.
+
+####
+# noop version of SolarWindsAPM::Metadata
+#
+#
+
+module SolarWindsAPM
+  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

data/lib/solarwinds_apm/noop/profiling.rb

@@ -0,0 +1,21 @@
+module SolarWindsAPM
+
+  # override the Ruby method, so that no code related to profiling gets executed
+  class Profiling
+
+    def self.run
+      yield
+    end
+  end
+
+  # these put the c-functions into "noop"
+  module CProfiler
+    def self.set_interval(_)
+      # do nothing
+    end
+
+    def self.get_tid
+      return 0
+    end
+  end
+end