solarwinds_apm 6.1.1 → 7.0.0.prev1

data/lib/solarwinds_apm/sampling/sampler.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
+#
+# 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.
+
+module SolarWindsAPM
+  class Sampler < OboeSampler
+    RUBY_SEM_CON = ::OpenTelemetry::SemanticConventions::Trace
+
+    ATTR_HTTP_REQUEST_METHOD = 'http.request.method'
+    ATTR_HTTP_METHOD = RUBY_SEM_CON::HTTP_METHOD
+    ATTR_HTTP_RESPONSE_STATUS_CODE = 'http.response.status_code'
+    ATTR_HTTP_STATUS_CODE = RUBY_SEM_CON::HTTP_STATUS_CODE
+    ATTR_URL_SCHEME = 'url.scheme'
+    ATTR_HTTP_SCHEME = RUBY_SEM_CON::HTTP_SCHEME
+    ATTR_SERVER_ADDRESS = 'server.address'
+    ATTR_NET_HOST_NAME = RUBY_SEM_CON::NET_HOST_NAME
+    ATTR_URL_PATH = 'url.path'
+    ATTR_HTTP_TARGET = RUBY_SEM_CON::HTTP_TARGET
+
+    # tracing_mode is getting from SolarWindsAPM::Config
+    def initialize(config, logger)
+      super(logger)
+      @tracing_mode = resolve_tracing_mode(config)
+      @trigger_mode = config[:trigger_trace_enabled]
+      @transaction_settings = config[:transaction_settings]
+      @ready = false
+    end
+
+    # wait for getting the first settings
+    def wait_until_ready(timeout = 10)
+      thread = Thread.new { settings_ready }
+      thread.join(timeout) || (thread.kill
+                               false)
+      @ready
+    end
+
+    def settings_ready(timeout = 10)
+      deadline = Time.now
+      loop do
+        break unless @settings.empty?
+
+        sleep 0.1
+        break if (Time.now - deadline).round(0) >= timeout
+      end
+      @ready = true unless @settings[:signature_key].nil?
+    end
+
+    def resolve_tracing_mode(config)
+      return unless config.key?(:tracing_mode) && !config[:tracing_mode].nil?
+
+      config[:tracing_mode] ? TracingMode::ALWAYS : TracingMode::NEVER
+    end
+
+    def local_settings(params)
+      _trace_id, _parent_context, _links, span_name, span_kind, attributes = params.values
+      settings = { tracing_mode: @tracing_mode, trigger_mode: @trigger_mode }
+      return settings if @transaction_settings.nil? || @transaction_settings.empty?
+
+      @logger.debug { "Current @transaction_settings: #{@transaction_settings.inspect}" }
+      http_metadata = http_span_metadata(span_kind, attributes)
+      @logger.debug { "http_metadata: #{http_metadata.inspect}" }
+
+      # below is for filter out unwanted transaction
+      trans_settings = ::SolarWindsAPM::TransactionSettings.new(url_path: http_metadata[:url], name: span_name, kind: span_kind)
+      tracing_mode   = trans_settings.calculate_trace_mode == 1 ? TracingMode::ALWAYS : TracingMode::NEVER
+
+      settings[:tracing_mode] = tracing_mode
+      settings
+    end
+
+    # if context have sw-related value, it should be stored in context
+    # named sw_xtraceoptions in header propagator
+    # original x_trace_options will parse headers in the class, apm-js separate the task
+    # apm-js will make headers as hash
+    def request_headers(params)
+      parent_context = params[:parent_context]
+      header = obtain_sw_value(parent_context, 'sw_xtraceoptions')
+      signature = obtain_sw_value(parent_context, 'sw_signature')
+      @logger.debug { "[#{self.class}/#{__method__}] trace_options option_header: #{header}; trace_options sw_signature: #{signature}" }
+
+      {
+        'X-Trace-Options' => header,
+        'X-Trace-Options-Signature' => signature
+      }
+    end
+
+    def obtain_sw_value(context, type)
+      sw_value = nil
+      instance_variable = context&.instance_variable_get('@entries')
+      instance_variable&.each do |key, value|
+        next unless key.instance_of?(::String)
+
+        sw_value = value if key == type
+      end
+      sw_value
+    end
+
+    def update_settings(settings)
+      parsed = parse_settings(settings)
+      if parsed
+        @logger.debug { "valid settings #{parsed.inspect} from setting #{settings.inspect}" }
+
+        super(parsed) # call oboe_sampler update_settings function to update the buckets
+
+        @logger.warn { "Warning from parsed settings: #{parsed[:warning]}" } if parsed[:warning]
+
+        parsed
+      else
+        @logger.debug { "invalid settings: #{settings.inspect}" }
+        nil
+      end
+    end
+
+    def http_span_metadata(kind, attributes)
+      return { http: false } unless kind == ::OpenTelemetry::Trace::SpanKind::SERVER &&
+                                    (attributes.key?(ATTR_HTTP_REQUEST_METHOD) || attributes.key?(ATTR_HTTP_METHOD))
+
+      method_ = (attributes[ATTR_HTTP_REQUEST_METHOD] || attributes[ATTR_HTTP_METHOD]).to_s
+      status = (attributes[ATTR_HTTP_RESPONSE_STATUS_CODE] || attributes[ATTR_HTTP_STATUS_CODE] || 0).to_i
+      scheme = (attributes[ATTR_URL_SCHEME] || attributes[ATTR_HTTP_SCHEME] || 'http').to_s
+      hostname = (attributes[ATTR_SERVER_ADDRESS] || attributes[ATTR_NET_HOST_NAME] || 'localhost').to_s
+      path = (attributes[ATTR_URL_PATH] || attributes[ATTR_HTTP_TARGET]).to_s
+      url = "#{scheme}://#{hostname}#{path}"
+
+      http_metadata = {
+        http: true,
+        method: method_,
+        status: status,
+        scheme: scheme,
+        hostname: hostname,
+        path: path,
+        url: url
+      }
+
+      @logger.debug { "Retrieved http metadata: #{http_metadata.inspect}" }
+      http_metadata
+    end
+
+    def parse_settings(unparsed)
+      return unless unparsed.is_a?(Hash)
+
+      return unless unparsed['value'].is_a?(Numeric) &&
+                    unparsed['timestamp'].is_a?(Numeric) &&
+                    unparsed['ttl'].is_a?(Numeric)
+
+      sample_rate = unparsed['value']
+      timestamp = unparsed['timestamp']
+      ttl = unparsed['ttl']
+
+      return unless unparsed['flags'].is_a?(String)
+
+      flags = unparsed['flags'].split(',').reduce(Flags::OK) do |final_flag, f|
+        flag = {
+          'OVERRIDE' => Flags::OVERRIDE,
+          'SAMPLE_START' => Flags::SAMPLE_START,
+          'SAMPLE_THROUGH_ALWAYS' => Flags::SAMPLE_THROUGH_ALWAYS,
+          'TRIGGER_TRACE' => Flags::TRIGGERED_TRACE
+        }[f]
+
+        final_flag |= flag if flag
+        final_flag
+      end
+
+      buckets = {}
+      signature_key = nil
+
+      if unparsed['arguments'].is_a?(Hash)
+        args = unparsed['arguments']
+
+        buckets[BucketType::DEFAULT] = { capacity: args['BucketCapacity'], rate: args['BucketRate'] } if args['BucketCapacity'].is_a?(Numeric) && args['BucketRate'].is_a?(Numeric)
+
+        buckets['trigger_relaxed'] = { capacity: args['TriggerRelaxedBucketCapacity'], rate: args['TriggerRelaxedBucketRate'] } if args['TriggerRelaxedBucketCapacity'].is_a?(Numeric) && args['TriggerRelaxedBucketRate'].is_a?(Numeric)
+
+        buckets['trigger_strict'] = { capacity: args['TriggerStrictBucketCapacity'], rate: args['TriggerStrictBucketRate'] } if args['TriggerStrictBucketCapacity'].is_a?(Numeric) && args['TriggerStrictBucketRate'].is_a?(Numeric)
+
+        signature_key = args['SignatureKey'] if args['SignatureKey'].is_a?(String)
+      end
+
+      warning = unparsed['warning'] if unparsed['warning'].is_a?(String)
+
+      {
+        sample_source: SampleSource::REMOTE,
+        sample_rate: sample_rate,
+        flags: flags,
+        timestamp: timestamp,
+        ttl: ttl,
+        buckets: buckets,
+        signature_key: signature_key,
+        warning: warning
+      }
+    end
+  end
+end

data/lib/solarwinds_apm/sampling/sampling_constants.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
+#
+# 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.
+
+module SolarWindsAPM
+  TriggerTraceOptions = Struct.new(
+    :trigger_trace,
+    :timestamp,
+    :sw_keys,
+    :custom,      # Hash
+    :ignored,     # Array
+    :response     # TraceOptionsResponse
+  )
+
+  TraceOptionsResponse = Struct.new(
+    :auth,           # Auth
+    :trigger_trace,  # TriggerTrace
+    :ignored         # Array
+  )
+
+  module Auth
+    OK = 'ok'
+    BAD_TIMESTAMP = 'bad-timestamp'
+    BAD_SIGNATURE = 'bad-signature'
+    NO_SIGNATURE_KEY = 'no-signature-key'
+  end
+
+  module TriggerTrace
+    OK = 'ok'
+    NOT_REQUESTED = 'not-requested'
+    IGNORED = 'ignored'
+    TRACING_DISABLED = 'tracing-disabled'
+    TRIGGER_TRACING_DISABLED = 'trigger-tracing-disabled'
+    RATE_EXCEEDED = 'rate-exceeded'
+    SETTINGS_NOT_AVAILABLE = 'settings-not-available'
+  end
+
+  Settings = Struct.new(:sample_rate,
+                        :sample_source,
+                        :flags,
+                        :buckets,           # BucketSettings
+                        :signature_key,
+                        :timestamp,
+                        :ttl)
+
+  LocalSettings = Struct.new(:tracing_mode, # TracingMode
+                             :trigger_mode) # {:enabled, :disabled}
+
+  BucketSettings = Struct.new(:capacity, # Number
+                              :rate) # Number
+
+  TokenBucketSettings = Struct.new(:capacity,    # Number
+                                   :rate,        # Number
+                                   :interval) # Number
+
+  module SampleSource
+    LOCAL_DEFAULT = 2
+    REMOTE = 6
+  end
+
+  module Flags
+    OK = 0x0
+    INVALID = 0x1
+    OVERRIDE = 0x2
+    SAMPLE_START = 0x4
+    SAMPLE_THROUGH_ALWAYS = 0x10
+    TRIGGERED_TRACE = 0x20
+  end
+
+  module TracingMode
+    ALWAYS = Flags::SAMPLE_START | Flags::SAMPLE_THROUGH_ALWAYS
+    NEVER = 0x0
+  end
+
+  module BucketType
+    DEFAULT = ''
+    TRIGGER_RELAXED = 'trigger_relaxed'
+    TRIGGER_STRICT = 'trigger_strict'
+  end
+
+  module SpanType
+    ROOT = 'root'
+    ENTRY = 'entry'
+    LOCAL = 'local'
+
+    VALID_TRACEID_REGEX = /^[0-9a-f]{32}$/i
+    VALID_SPANID_REGEX = /^[0-9a-f]{16}$/i
+
+    INVALID_SPANID = '0000000000000000'
+    INVALID_TRACEID = '00000000000000000000000000000000'
+
+    def self.span_type(parent_span)
+      parent_span_context = parent_span&.context
+      if parent_span_context.nil? || !span_context_valid?(parent_span_context)
+        ROOT
+      elsif parent_span_context.remote?
+        ENTRY
+      else
+        LOCAL
+      end
+    end
+
+    def self.valid_trace_id?(trace_id)
+      !!(trace_id =~ VALID_TRACEID_REGEX) && trace_id != INVALID_TRACEID
+    end
+
+    def self.valid_span_id?(span_id)
+      !!(span_id =~ VALID_SPANID_REGEX) && span_id != INVALID_SPANID
+    end
+
+    def self.span_context_valid?(span_context)
+      valid_trace_id?(span_context.hex_trace_id) && valid_span_id?(span_context.hex_span_id)
+    end
+  end
+
+  SampleState = Struct.new(:decision,     # SamplingDecision
+                           :attributes,   # Attributes
+                           :params,       # SampleParams
+                           :settings,     # Settings
+                           :trace_state, # String
+                           :headers, # RequestHeaders
+                           :trace_options) # TraceOptions & { response: TraceOptionsResponse })
+end

data/lib/solarwinds_apm/sampling/sampling_patch.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolarWindsAPM
+  module MetricsExporter
+    module Patch
+      # do not send metrics if no data_points present
+      def export(metrics, timeout: nil)
+        metrics.reject! { |m| m.data_points.empty? }
+        return ::OpenTelemetry::SDK::Metrics::Export::SUCCESS unless metrics.any? { |m| m.data_points.any? }
+
+        super
+      end
+    end
+  end
+end
+
+module SolarWindsAPM
+  module Span
+    module Patch
+      def finish(end_timestamp: nil)
+        @mutex.synchronize do
+          if @ended
+            ::OpenTelemetry.logger.warn('Calling finish on an ended Span.')
+            return self
+          end
+        end
+
+        @span_processors.each do |processor|
+          processor.on_finishing(self) if processor.respond_to?(:on_finishing)
+        end
+
+        @mutex.synchronize do
+          @end_timestamp = relative_timestamp(end_timestamp)
+          @attributes = validated_attributes(@attributes).freeze
+          @events.freeze
+          @links.freeze
+          @ended = true
+        end
+        @span_processors.each { |processor| processor.on_finish(self) }
+        self
+      end
+    end
+  end
+end
+
+OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter.prepend(SolarWindsAPM::MetricsExporter::Patch)
+
+# issue: https://github.com/open-telemetry/opentelemetry-ruby/issues/1824
+OpenTelemetry::SDK::Trace::Span.prepend(SolarWindsAPM::Span::Patch)

data/lib/solarwinds_apm/sampling/setting_example.txt

@@ -0,0 +1 @@
+{"value"=>1000000, "flags"=>"SAMPLE_START,SAMPLE_THROUGH_ALWAYS,SAMPLE_BUCKET_ENABLED,TRIGGER_TRACE", "timestamp"=>1738523568, "ttl"=>120, "arguments"=>{"BucketCapacity"=>2, "BucketRate"=>1, "TriggerRelaxedBucketCapacity"=>20, "TriggerRelaxedBucketRate"=>1, "TriggerStrictBucketCapacity"=>6, "TriggerStrictBucketRate"=>0.1, "SignatureKey"=>"0sftj1EYX7JJp01DblJwkccYCIZ91fbU"}}

data/lib/solarwinds_apm/{noop/context.rb → sampling/settings.rb}

@@ -6,34 +6,23 @@
 #
 # 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.
 
-####
-# noop version of SolarWindsAPM::Context
-#
-# module SolarWindsAPM
-# end
+module SolarWindsAPM
+  module SamplingSettings
+    def self.merge(remote, local)
+      flags = local[:tracing_mode] || remote[:flags]
 
-module Oboe_metal # rubocop:disable Naming/ClassAndModuleCamelCase
-  # Context for noop
-  class Context
-    ##
-    # noop version of :toString
-    # toString would return the current trace context as string
-    #
-    def self.toString
-      '99-00000000000000000000000000000000-0000000000000000-00'
-    end
+      if local[:trigger_mode] == :enabled
+        flags |= SolarWindsAPM::Flags::TRIGGERED_TRACE
+      elsif local[:trigger_mode] == :disabled
+        flags &= ~ SolarWindsAPM::Flags::TRIGGERED_TRACE
+      end
 
-    def self.isReady(*)
-      false
-    end
+      if remote[:flags].anybits?(SolarWindsAPM::Flags::OVERRIDE)
+        flags &= remote[:flags]
+        flags |= SolarWindsAPM::Flags::OVERRIDE
+      end
 
-    def self.getDecisions(*)
-      [-1, -1, -1, 0, 0.0, 0.0, -1, -1, '', '', 4]
+      remote.dup.tap { |merged| merged[:flags] = flags }
     end
-
-    ##
-    # noop version of :clear
-    #
-    def self.clear; end
   end
 end

data/lib/solarwinds_apm/sampling/token_bucket.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
+#
+# 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.
+
+# Bucket is used to consume that determine if capacity is enough
+# capacity is updated through update_settings
+module SolarWindsAPM
+  class TokenBucket
+    # Maximum value of a signed 32-bit integer
+    MAX_INTERVAL = (2**31) - 1
+
+    attr_reader :capacity, :rate, :interval, :tokens
+
+    def initialize(token_bucket_settings)
+      self.capacity = token_bucket_settings.capacity || 0
+      self.rate = token_bucket_settings.rate || 0
+      self.interval = token_bucket_settings.interval || MAX_INTERVAL
+      self.tokens = @capacity
+      @timer = nil
+    end
+
+    # used call from update_settings e.g. bucket.update(bucket_settings)
+    def update(settings)
+      settings.instance_of?(Hash) ? update_from_hash(settings) : update_from_token_bucket_settings(settings)
+    end
+
+    def update_from_hash(settings)
+      if settings[:capacity]
+        difference = settings[:capacity] - @capacity
+        self.capacity = settings[:capacity]
+        self.tokens = @tokens + difference
+      end
+
+      self.rate = settings[:rate] if settings[:rate]
+
+      return unless settings[:interval]
+
+      self.interval = settings[:interval]
+      return unless running
+
+      stop
+      start
+    end
+
+    def update_from_token_bucket_settings(settings)
+      if settings.capacity
+        difference = settings.capacity - @capacity
+        self.capacity = settings.capacity
+        self.tokens = @tokens + difference
+      end
+
+      self.rate = settings.rate if settings.rate
+
+      return unless settings.interval
+
+      self.interval = settings.interval
+      return unless running
+
+      stop
+      start
+    end
+
+    def capacity=(capacity)
+      @capacity = [0, capacity].max
+    end
+
+    def rate=(rate)
+      @rate = [0, rate].max
+    end
+
+    def interval=(interval)
+      @interval = interval.clamp(0, MAX_INTERVAL)
+    end
+
+    def tokens=(tokens)
+      @tokens = tokens.clamp(0, @capacity)
+    end
+
+    # Attempts to consume tokens from the bucket
+    # @param n [Integer] Number of tokens to consume
+    # @return [Boolean] Whether there were enough tokens
+    def consume(token = 1)
+      if @tokens >= token
+        self.tokens = @tokens - token
+        true
+      else
+        false
+      end
+    end
+
+    # Starts replenishing the bucket
+    def start
+      return if running
+
+      @timer = Thread.new do
+        loop do
+          task
+          sleep(@interval / 1000.0)
+        end
+      end
+    end
+
+    # Stops replenishing the bucket
+    def stop
+      return unless running
+
+      @timer.kill
+      @timer = nil
+    end
+
+    # Whether the bucket is actively being replenished
+    def running
+      !@timer.nil?
+    end
+
+    private
+
+    def task
+      self.tokens = tokens + @rate
+    end
+  end
+end

data/lib/solarwinds_apm/sampling/trace_options.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
+#
+# 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.
+
+module SolarWindsAPM
+  class TraceOptions
+    TRIGGER_TRACE_KEY = 'trigger-trace'
+    TIMESTAMP_KEY = 'ts'
+    SW_KEYS_KEY = 'sw-keys'
+
+    CUSTOM_KEY_REGEX = /^custom-[^\s]*$/
+
+    def self.parse_trace_options(header, logger)
+      trace_options = TriggerTraceOptions.new(nil, nil, nil, {}, [], TraceOptionsResponse.new(nil, nil, []))
+
+      kvs = header.split(';').map do |kv|
+        key, *values = kv.split('=').map(&:strip)
+        value = values.any? ? values.join('=') : nil
+        [key, value]
+      end
+
+      kvs.reject! { |key, _| key.nil? || key.empty? }
+
+      kvs.each do |k, v|
+        case k
+        when TRIGGER_TRACE_KEY
+          if v || trace_options.trigger_trace
+            logger.debug { 'invalid trace option for trigger trace' }
+            trace_options.ignored << [k, v]
+            next
+          end
+          trace_options.trigger_trace = true
+        when TIMESTAMP_KEY
+          if v.nil? || trace_options.timestamp
+            logger.debug { 'invalid trace option for timestamp' }
+            trace_options.ignored << [k, v]
+            next
+          end
+
+          unless numeric_integer?(v)
+            logger.debug { 'invalid trace option for timestamp, should be an integer' }
+            trace_options.ignored << [k, v]
+            next
+          end
+          trace_options.timestamp = v.to_i
+        when SW_KEYS_KEY
+          if v.nil? || trace_options.sw_keys
+            logger.debug { 'invalid trace option for sw keys' }
+            trace_options.ignored << [k, v]
+            next
+          end
+          trace_options.sw_keys = v
+        when CUSTOM_KEY_REGEX
+          if v.nil? || trace_options.custom[k]
+            logger.debug { "invalid trace option for custom key #{k}" }
+            trace_options.ignored << [k, v]
+            next
+          end
+          trace_options.custom[k] = v
+        else
+          trace_options.ignored << [k, v]
+        end
+      end
+
+      trace_options
+    end
+
+    def self.numeric_integer?(str)
+      true if Integer(str)
+    rescue StandardError
+      false
+    end
+
+    # combine the array to string separate by ;
+    # tracestate doesn't accept value with k=v, here we use k:v
+    # but it will be replaced with = when inject in respond header
+    def self.stringify_trace_options_response(trace_options_response)
+      return if trace_options_response.nil?
+
+      kvs = {
+        auth: trace_options_response.auth,
+        'trigger-trace': trace_options_response.trigger_trace,
+        ignored: trace_options_response.ignored.empty? ? nil : trace_options_response.ignored.join(',')
+      }
+      kvs.compact.map { |k, v| "#{k}:#{v}" }.join(';')
+    end
+
+    def self.validate_signature(header, signature, key, timestamp)
+      return Auth::NO_SIGNATURE_KEY unless key
+      return Auth::BAD_TIMESTAMP unless timestamp && (Time.now.to_i - timestamp).abs <= 5 * 60
+
+      digest = OpenSSL::HMAC.hexdigest('SHA1', key, header)
+      signature == digest ? Auth::OK : Auth::BAD_SIGNATURE
+    end
+  end
+end

data/lib/solarwinds_apm/{patch.rb → sampling.rb}

@@ -6,8 +6,24 @@
 #
 # 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.
 
-# This file is for loading any customized patch for upstream
+require 'json'
+require 'fileutils'
+require 'tempfile'
+require 'uri'
+require 'opentelemetry-sdk'
 
-# e.g.
-# require_relative './patch/dummy_patch'
-# OpenTelemetry::Instrumentation::Registry.prepend(SolarWindsAPM::Patch::DummyPatch) if defined? OpenTelemetry::Instrumentation::Registry && OpenTelemetry::Instrumentation::Registry::VERSION <= '0.3.0'
+require_relative 'sampling/sampling_constants'
+require_relative 'sampling/dice'
+require_relative 'sampling/settings'
+require_relative 'sampling/token_bucket'
+require_relative 'sampling/trace_options'
+require_relative 'sampling/metrics'
+
+# HttpSampler/JsonSampler < Sampler < OboeSampler
+require_relative 'sampling/oboe_sampler'
+require_relative 'sampling/sampler'
+require_relative 'sampling/http_sampler'
+require_relative 'sampling/json_sampler'
+
+# Patching
+require_relative 'sampling/sampling_patch'