solarwinds_apm 7.0.1 → 7.1.0

data/lib/solarwinds_apm/sampling/oboe_sampler.rb

@@ -30,13 +30,14 @@ module SolarWindsAPM
       @counters = SolarWindsAPM::Metrics::Counter.new
       @buckets = {
         SolarWindsAPM::BucketType::DEFAULT =>
-          SolarWindsAPM::TokenBucket.new(SolarWindsAPM::TokenBucketSettings.new(nil, nil, BUCKET_INTERVAL)),
+          SolarWindsAPM::TokenBucket.new(SolarWindsAPM::TokenBucketSettings.new(nil, nil, BUCKET_INTERVAL, 'DEFUALT')),
         SolarWindsAPM::BucketType::TRIGGER_RELAXED =>
-          SolarWindsAPM::TokenBucket.new(SolarWindsAPM::TokenBucketSettings.new(nil, nil, BUCKET_INTERVAL)),
+          SolarWindsAPM::TokenBucket.new(SolarWindsAPM::TokenBucketSettings.new(nil, nil, BUCKET_INTERVAL, 'TRIGGER_RELAXED')),
         SolarWindsAPM::BucketType::TRIGGER_STRICT =>
-          SolarWindsAPM::TokenBucket.new(SolarWindsAPM::TokenBucketSettings.new(nil, nil, BUCKET_INTERVAL))
+          SolarWindsAPM::TokenBucket.new(SolarWindsAPM::TokenBucketSettings.new(nil, nil, BUCKET_INTERVAL, 'TRIGGER_STRICT'))
       }
       @settings = {} # parsed setting from swo backend
+      @settings_mutex = ::Mutex.new
 
       @buckets.each_value(&:start)
     end
@@ -45,19 +46,22 @@ module SolarWindsAPM
     # params: {:trace_id=>, :parent_context=>, :links=>, :name=>, :kind=>, :attributes=>}
     # propagator -> processor -> sampler
     def should_sample?(params)
-      @logger.debug { "should_sample? params: #{params.inspect}" }
       _, parent_context, _, _, _, attributes = params.values
 
       parent_span = ::OpenTelemetry::Trace.current_span(parent_context)
       type = SolarWindsAPM::SpanType.span_type(parent_span)
 
-      @logger.debug { "[#{self.class}/#{__method__}] span type is #{type}" }
+      @logger.debug { "[#{self.class}/#{__method__}] should_sample? params: #{params.inspect}; span type is #{type}" }
 
       # For local spans, we always trust the parent
       if type == SolarWindsAPM::SpanType::LOCAL
-        return OTEL_SAMPLING_RESULT.new(decision: OTEL_SAMPLING_DECISION::RECORD_AND_SAMPLE, tracestate: DEFAULT_TRACESTATE) if parent_span.context.trace_flags.sampled?
-
-        return OTEL_SAMPLING_RESULT.new(decision: OTEL_SAMPLING_DECISION::DROP, tracestate: DEFAULT_TRACESTATE)
+        if parent_span.context.trace_flags.sampled?
+          return OTEL_SAMPLING_RESULT.new(decision: OTEL_SAMPLING_DECISION::RECORD_AND_SAMPLE,
+                                          tracestate: DEFAULT_TRACESTATE)
+        else
+          return OTEL_SAMPLING_RESULT.new(decision: OTEL_SAMPLING_DECISION::DROP,
+                                          tracestate: DEFAULT_TRACESTATE)
+        end
       end
 
       sample_state = SampleState.new(OTEL_SAMPLING_DECISION::DROP,
@@ -78,10 +82,9 @@ module SolarWindsAPM
         # TraceOptions.parse_trace_options return TriggerTraceOptions
         sample_state.trace_options = ::SolarWindsAPM::TraceOptions.parse_trace_options(sample_state.headers['X-Trace-Options'], @logger)
 
-        @logger.debug { "X-Trace-Options present: #{sample_state.trace_options}" }
+        @logger.debug { "[#{self.class}/#{__method__}] sample_state.trace_options: #{sample_state.trace_options.inspect}" }
 
         if sample_state.headers['X-Trace-Options-Signature']
-          @logger.debug { 'X-Trace-Options-Signature present; validating' }
 
           # this validate_signature is the function from trace_options file
           sample_state.trace_options.response.auth = TraceOptions.validate_signature(
@@ -92,36 +95,27 @@ module SolarWindsAPM
           )
 
           # If the request has an invalid signature, drop the trace
-          if sample_state.trace_options.response.auth != Auth::OK # Auth::OK is a string from trace_options.rb: 'ok'
-            @logger.debug { 'X-Trace-Options-Signature invalid; tracing disabled' }
+          if sample_state.trace_options.response.auth != Auth::OK
+            @logger.debug { "[#{self.class}/#{__method__}] signature invalid; tracing disabled (auth=#{sample_state.trace_options.response.auth})" }
 
             xtracestate = generate_new_tracestate(parent_span, sample_state)
-            return OTEL_SAMPLING_RESULT.new(decision: OTEL_SAMPLING_DECISION::DROP, tracestate: xtracestate, attributes: sample_state.attributes)
+            return OTEL_SAMPLING_RESULT.new(decision: OTEL_SAMPLING_DECISION::DROP,
+                                            tracestate: xtracestate,
+                                            attributes: sample_state.attributes)
           end
         end
 
-        unless sample_state.trace_options.trigger_trace
-          sample_state.trace_options.response.trigger_trace = TriggerTrace::NOT_REQUESTED # 'not-requested'
-        end
-
-        # Apply trace options to span attributes
+        # Apply trace options to span attributes and list ignored keys in response
+        sample_state.trace_options.response.trigger_trace = TriggerTrace::NOT_REQUESTED unless sample_state.trace_options.trigger_trace
         sample_state.attributes[SW_KEYS_ATTRIBUTE] = sample_state.trace_options[:sw_keys] if sample_state.trace_options[:sw_keys]
-
-        sample_state.trace_options.custom.each do |k, v|
-          sample_state.attributes[k] = v
-        end
-
-        # List ignored keys in response
+        sample_state.trace_options.custom.each { |k, v| sample_state.attributes[k] = v }
         sample_state.trace_options.response.ignored = sample_state.trace_options[:ignored].map { |k, _| k } if sample_state.trace_options[:ignored].any?
       end
 
       unless sample_state.settings
-        @logger.debug { 'settings unavailable; sampling disabled' }
+        @logger.debug { "[#{self.class}/#{__method__}] settings unavailable; sampling disabled" }
 
-        if sample_state.trace_options&.trigger_trace
-          @logger.debug { 'trigger trace requested but unavailable' }
-          sample_state.trace_options.response.trigger_trace = TriggerTrace::SETTINGS_NOT_AVAILABLE # 'settings-not-available'
-        end
+        sample_state.trace_options.response.trigger_trace = TriggerTrace::SETTINGS_NOT_AVAILABLE if sample_state.trace_options&.trigger_trace
 
         xtracestate = generate_new_tracestate(parent_span, sample_state)
 
@@ -131,31 +125,23 @@ module SolarWindsAPM
       end
 
       @logger.debug { "[#{self.class}/#{__method__}] sample_state before deciding sampling algo: #{sample_state.inspect}" }
+
       # Decide which sampling algo to use and add sampling attribute to decision attributes
       # https://swicloud.atlassian.net/wiki/spaces/NIT/pages/3815473156/Tracing+Decision+Tree
       if sample_state.trace_state && TRACESTATE_REGEXP.match?(sample_state.trace_state)
-        @logger.debug { 'context is valid for parent-based sampling' }
         parent_based_algo(sample_state)
-
       elsif sample_state.settings[:flags].anybits?(Flags::SAMPLE_START)
         if sample_state.trace_options&.trigger_trace
-          @logger.debug { 'trigger trace requested' }
           trigger_trace_algo(sample_state)
         else
-          @logger.debug { 'defaulting to dice roll' }
           dice_roll_algo(sample_state)
         end
       else
-        @logger.debug { 'SAMPLE_START is unset; sampling disabled' }
         disabled_algo(sample_state)
       end
 
-      @logger.debug { "final sampling state: #{sample_state.inspect}" }
-
       xtracestate = generate_new_tracestate(parent_span, sample_state)
-
-      # if need to set 'sw.w3c.tracestate' to attributes
-      # sample_state.attributes['sw.w3c.tracestate'] = ::SolarWindsAPM::Utils.trace_state_header(xtracestate)
+      @logger.debug { "[#{self.class}/#{__method__}] final sampling state: #{sample_state.inspect}" }
 
       OTEL_SAMPLING_RESULT.new(decision: sample_state.decision,
                                tracestate: xtracestate,
@@ -163,13 +149,10 @@ module SolarWindsAPM
     end
 
     def parent_based_algo(sample_state)
-      # original js code: const [context] = s.params
-      # the context is used for metrics e.g. this.#counters.throughTraceCount.add(1, {}, context)
+      @logger.debug { "[#{self.class}/#{__method__}] parent_based_algo start" }
 
-      # compare the parent_id
       sample_state.attributes[PARENT_ID_ATTRIBUTE] = sample_state.trace_state[0, 16]
-
-      if sample_state.trace_options&.trigger_trace # need to implement trace_options
+      if sample_state.trace_options&.trigger_trace
         @logger.debug { 'trigger trace requested but ignored' }
         sample_state.trace_options.response.trigger_trace = TriggerTrace::IGNORED # 'ignored'
       end
@@ -198,18 +181,22 @@ module SolarWindsAPM
           @logger.debug { 'parent is sampled; record and sample' }
 
           @counters[:trace_count].add(1)
-          @counters[:through_trace_count].add(1) # ruby metrics only add incremented value and attributes
+          @counters[:through_trace_count].add(1)
 
           sample_state.decision = OTEL_SAMPLING_DECISION::RECORD_AND_SAMPLE
         end
       end
+
+      @logger.debug { "[#{self.class}/#{__method__}] parent_based_algo end" }
     end
 
     def trigger_trace_algo(sample_state)
+      @logger.debug { "[#{self.class}/#{__method__}] trigger_trace_algo start" }
+
       if sample_state.settings[:flags].nobits?(Flags::TRIGGERED_TRACE)
         @logger.debug { 'TRIGGERED_TRACE unset; record only' }
 
-        sample_state.trace_options.response.trigger_trace = TriggerTrace::TRIGGER_TRACING_DISABLED # 'trigger-tracing-disabled'
+        sample_state.trace_options.response.trigger_trace = TriggerTrace::TRIGGER_TRACING_DISABLED
         sample_state.decision = OTEL_SAMPLING_DECISION::RECORD_ONLY
       else
         @logger.debug { 'TRIGGERED_TRACE set; trigger tracing' }
@@ -244,9 +231,12 @@ module SolarWindsAPM
           sample_state.decision = OTEL_SAMPLING_DECISION::RECORD_ONLY
         end
       end
+      @logger.debug { "[#{self.class}/#{__method__}] trigger_trace_algo end" }
     end
 
     def dice_roll_algo(sample_state)
+      @logger.debug { "[#{self.class}/#{__method__}] dice_roll_algo start" }
+
       dice = SolarWindsAPM::Dice.new(rate: sample_state.settings[:sample_rate], scale: DICE_SCALE)
       sample_state.attributes[SAMPLE_RATE_ATTRIBUTE] = dice.rate
       sample_state.attributes[SAMPLE_SOURCE_ATTRIBUTE] = sample_state.settings[:sample_source]
@@ -278,9 +268,11 @@ module SolarWindsAPM
         @logger.debug { 'dice roll failure; record only' }
         sample_state.decision = OTEL_SAMPLING_DECISION::RECORD_ONLY
       end
+      @logger.debug { "[#{self.class}/#{__method__}] dice_roll_algo end" }
     end
 
     def disabled_algo(sample_state)
+      @logger.debug { "[#{self.class}/#{__method__}] disabled_algo start" }
       if sample_state.trace_options&.trigger_trace
         @logger.debug { 'trigger trace requested but tracing disabled' }
         sample_state.trace_options.response.trigger_trace = TriggerTrace::TRACING_DISABLED
@@ -293,14 +285,17 @@ module SolarWindsAPM
         @logger.debug { 'SAMPLE_THROUGH_ALWAYS is set; record' }
         sample_state.decision = OTEL_SAMPLING_DECISION::RECORD_ONLY
       end
+      @logger.debug { "[#{self.class}/#{__method__}] disabled_algo end" }
     end
 
     def update_settings(settings)
       return unless settings[:timestamp] > (@settings[:timestamp] || 0)
 
-      @settings = settings
-      @buckets.each do |type, bucket|
-        bucket.update(@settings[:buckets][type]) if @settings[:buckets][type]
+      @settings_mutex.synchronize do
+        @settings = settings
+        @buckets.each do |type, bucket|
+          bucket.update(@settings[:buckets][type]) if @settings[:buckets][type]
+        end
       end
     end
 
@@ -308,26 +303,24 @@ module SolarWindsAPM
     # handle_response_headers functionality is replace by generate_new_tracestate
     def generate_new_tracestate(parent_span, sample_state)
       if !parent_span.context.valid? || parent_span.context.tracestate.nil?
-        @logger.debug { 'create new tracestate' }
+        action = 'create'
         decision = sw_from_span_and_decision(parent_span, sample_state.decision)
         trace_state = ::OpenTelemetry::Trace::Tracestate.from_hash({ 'sw' => decision })
       else
-        @logger.debug { 'update tracestate' }
+        action = 'update'
         decision = sw_from_span_and_decision(parent_span, sample_state.decision)
         trace_state = parent_span.context.tracestate.set_value('sw', decision)
       end
 
       stringified_trace_options = SolarWindsAPM::TraceOptions.stringify_trace_options_response(sample_state.trace_options&.response)
-      @logger.debug { "[#{self.class}/#{__method__}] stringified_trace_options: #{stringified_trace_options}" }
-
       trace_state = trace_state.set_value('xtrace_options_response', stringified_trace_options)
-      @logger.debug { "[#{self.class}/#{__method__}] new trace_state: #{trace_state.inspect}" }
+      @logger.debug { "[#{self.class}/#{__method__}] Tracestate #{action}: decision=#{decision[-2, 2]}, xtrace_resp=#{stringified_trace_options}, trace_state=#{trace_state.inspect}" }
       trace_state
     end
 
     def sw_from_span_and_decision(parent_span, otel_decision)
       trace_flag = otel_decision == OTEL_SAMPLING_DECISION::RECORD_AND_SAMPLE ? '01' : '00'
-      [parent_span.context.hex_span_id, trace_flag].join('-')
+      "#{parent_span.context.hex_span_id}-#{trace_flag}"
     end
 
     def get_settings(params)
@@ -336,12 +329,12 @@ module SolarWindsAPM
       expiry = (@settings[:timestamp] + @settings[:ttl]) * 1000
       time_now = Time.now.to_i * 1000
       if time_now > expiry
-        @logger.debug { 'settings expired, removing' }
+        @logger.debug { "[#{self.class}/#{__method__}] settings expired, removing" }
         @settings = {}
         return
       end
       sampling_setting = SolarWindsAPM::SamplingSettings.merge(@settings, local_settings(params))
-      @logger.debug { "sampling_setting: #{sampling_setting.inspect}" }
+      @logger.debug { "[#{self.class}/#{__method__}] sampling_setting: #{sampling_setting.inspect}" }
       sampling_setting
     end
   end

data/lib/solarwinds_apm/sampling/sampler.rb

@@ -21,6 +21,9 @@ module SolarWindsAPM
     ATTR_URL_PATH = 'url.path'
     ATTR_HTTP_TARGET = RUBY_SEM_CON::HTTP_TARGET
 
+    SW_XTRACEOPTIONS_KEY = 'sw_xtraceoptions'
+    SW_SIGNATURE_KEY = 'sw_signature'
+
     # tracing_mode is getting from SolarWindsAPM::Config
     def initialize(config, logger)
       super(logger)
@@ -28,25 +31,22 @@ module SolarWindsAPM
       @trigger_mode = config[:trigger_trace_enabled]
       @transaction_settings = config[:transaction_settings]
       @ready = false
+      @logger.debug { "[#{self.class}/#{__method__}] Sampler initialized: tracing_mode=#{@tracing_mode}, trigger_mode=#{@trigger_mode}, transaction_settings_count=#{@transaction_settings.inspect}" }
     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?
-
+      deadline = Time.now + timeout
+      while Time.now < deadline
+        # The @settings hash is populated by another thread (e.g., HttpSampler)
+        unless @settings.empty?
+          @ready = !@settings[:signature_key].nil?
+          return @ready
+        end
         sleep 0.1
-        break if (Time.now - deadline).round(0) >= timeout
       end
-      @ready = true unless @settings[:signature_key].nil?
+
+      @logger.warn { "[#{self.class}/#{__method__}] Timed out waiting for settings after #{timeout} seconds." }
+      @ready # Will be false if timeout is reached
     end
 
     def resolve_tracing_mode(config)
@@ -58,59 +58,45 @@ module SolarWindsAPM
     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}" }
+      if @transaction_settings.nil? || @transaction_settings.empty?
+        @logger.debug { "[#{self.class}/#{__method__}] No transaction settings, using defaults settings: #{settings.inspect}" }
+      else
+        http_metadata = http_span_metadata(span_kind, attributes)
+        # 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
 
-      # 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
+      end
 
-      settings[:tracing_mode] = tracing_mode
+      @logger.debug { "[#{self.class}/#{__method__}] Transaction settings after calculation #{settings.inspect}" }
       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
+    # named sw_xtraceoptions and sw_signature in header from propagator
     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
-      }
+      header, signature = obtain_traceoptions_headers_signature(params[:parent_context])
+      @logger.debug { "[#{self.class}/#{__method__}] trace_options header: #{header.inspect}, signature: #{signature.inspect} from parent_context: #{params[:parent_context].inspect}" }
+      { '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
+    def obtain_traceoptions_headers_signature(context)
+      header = context.value(SW_XTRACEOPTIONS_KEY)
+      signature = context.value(SW_SIGNATURE_KEY)
+      [header, signature]
     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.debug { "[#{self.class}/#{__method__}] Valid settings #{parsed.inspect} from setting #{settings.inspect}" }
         @logger.warn { "Warning from parsed settings: #{parsed[:warning]}" } if parsed[:warning]
-
+        super(parsed) # call oboe_sampler update_settings function to update the buckets
         parsed
       else
-        @logger.debug { "invalid settings: #{settings.inspect}" }
+        @logger.debug { "[#{self.class}/#{__method__}] Invalid settings: #{settings.inspect}" }
         nil
       end
     end
@@ -136,24 +122,25 @@ module SolarWindsAPM
         url: url
       }
 
-      @logger.debug { "Retrieved http metadata: #{http_metadata.inspect}" }
+      @logger.debug { "[#{self.class}/#{__method__}] 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']
+      timestamp   = unparsed['timestamp']
+      ttl         = unparsed['ttl']
+      flags       = unparsed['flags']
+
+      return unless sample_rate.is_a?(Numeric) &&
+                    timestamp.is_a?(Numeric) &&
+                    ttl.is_a?(Numeric)
 
-      return unless unparsed['flags'].is_a?(String)
+      return unless flags.is_a?(String)
 
-      flags = unparsed['flags'].split(',').reduce(Flags::OK) do |final_flag, f|
+      flags = flags.split(',').reduce(Flags::OK) do |final_flag, f|
         flag = {
           'OVERRIDE' => Flags::OVERRIDE,
           'SAMPLE_START' => Flags::SAMPLE_START,
@@ -167,6 +154,7 @@ module SolarWindsAPM
 
       buckets = {}
       signature_key = nil
+      warning = nil
 
       if unparsed['arguments'].is_a?(Hash)
         args = unparsed['arguments']

data/lib/solarwinds_apm/sampling/sampling_constants.rb

@@ -55,7 +55,8 @@ module SolarWindsAPM
 
   TokenBucketSettings = Struct.new(:capacity,    # Number
                                    :rate,        # Number
-                                   :interval) # Number
+                                   :interval,    # Number
+                                   :type)        # String
 
   module SampleSource
     LOCAL_DEFAULT = 2
@@ -105,11 +106,11 @@ module SolarWindsAPM
     end
 
     def self.valid_trace_id?(trace_id)
-      !!(trace_id =~ VALID_TRACEID_REGEX) && trace_id != INVALID_TRACEID
+      VALID_TRACEID_REGEX.match?(trace_id) && trace_id != INVALID_TRACEID
     end
 
     def self.valid_span_id?(span_id)
-      !!(span_id =~ VALID_SPANID_REGEX) && span_id != INVALID_SPANID
+      VALID_SPANID_REGEX.match?(span_id) && span_id != INVALID_SPANID
     end
 
     def self.span_context_valid?(span_context)

data/lib/solarwinds_apm/sampling/settings.rb

@@ -9,6 +9,7 @@
 module SolarWindsAPM
   module SamplingSettings
     def self.merge(remote, local)
+      SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] SamplingSettings merge with remote: #{remote.inspect}; local: #{local.inspect}" }
       flags = local[:tracing_mode] || remote[:flags]
 
       if local[:trigger_mode] == :enabled
@@ -22,6 +23,7 @@ module SolarWindsAPM
         flags |= SolarWindsAPM::Flags::OVERRIDE
       end
 
+      SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] final flags: #{flags}" }
       remote.merge(flags: flags)
     end
   end

data/lib/solarwinds_apm/sampling/token_bucket.rb

@@ -13,17 +13,19 @@ module SolarWindsAPM
     # Maximum value of a signed 32-bit integer
     MAX_INTERVAL = (2**31) - 1
 
-    attr_reader :capacity, :rate, :interval, :tokens
+    attr_reader :capacity, :rate, :interval, :tokens, :type
 
     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
+      @type = token_bucket_settings.type
       @timer = nil
     end
 
-    # used call from update_settings e.g. bucket.update(bucket_settings)
+    # oboe sampler update_settings will update the token
+    # (thread safe as update_settings is guarded by mutex from oboe sampler)
     def update(settings)
       settings.instance_of?(Hash) ? update_from_hash(settings) : update_from_token_bucket_settings(settings)
     end
@@ -72,8 +74,11 @@ module SolarWindsAPM
       @rate = [0, rate].max
     end
 
+    # self.interval= sets the @interval and @sleep_interval
+    # @sleep_interval is used in the timer thread to sleep between replenishing the bucket
     def interval=(interval)
       @interval = interval.clamp(0, MAX_INTERVAL)
+      @sleep_interval = @interval / 1000.0
     end
 
     def tokens=(tokens)
@@ -83,11 +88,15 @@ module SolarWindsAPM
     # Attempts to consume tokens from the bucket
     # @param n [Integer] Number of tokens to consume
     # @return [Boolean] Whether there were enough tokens
+    # TODO: we need to include thread-safety here since sampler is shared across threads
+    # and we may have multiple threads trying to consume tokens at the same time
     def consume(token = 1)
       if @tokens >= token
         self.tokens = @tokens - token
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] #{@type} Consumed #{token} from total #{@tokens} (#{(@tokens.to_f / @capacity * 100).round(1)}% remaining)" }
         true
       else
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] #{@type} Token consumption failed: requested=#{token}, available=#{@tokens}, capacity=#{@capacity}" }
         false
       end
     end
@@ -99,7 +108,7 @@ module SolarWindsAPM
       @timer = Thread.new do
         loop do
           task
-          sleep(@interval / 1000.0)
+          sleep(@sleep_interval)
         end
       end
     end

data/lib/solarwinds_apm/sampling/trace_options.rb

@@ -9,63 +9,66 @@
 module SolarWindsAPM
   class TraceOptions
     TRIGGER_TRACE_KEY = 'trigger-trace'
-    TIMESTAMP_KEY = 'ts'
-    SW_KEYS_KEY = 'sw-keys'
-
-    CUSTOM_KEY_REGEX = /^custom-[^\s]*$/
+    TIMESTAMP_KEY     = 'ts'
+    SW_KEYS_KEY       = 'sw-keys'
+    CUSTOM_KEY_REGEX  = /^custom-[^\s]*$/
 
     def self.parse_trace_options(header, logger)
+      logger.debug { "[#{self.class}/#{__method__}] Parsing trace options header: #{header&.slice(0, 100)}..." }
       trace_options = TriggerTraceOptions.new(nil, nil, nil, {}, [], TraceOptionsResponse.new(nil, nil, []))
 
-      kvs = header.split(';').map do |kv|
+      kvs = header.split(';').filter_map do |kv|
         key, *values = kv.split('=').map(&:strip)
+        next if key.nil? || key.empty?
+
         value = values.any? ? values.join('=') : nil
         [key, value]
       end
 
-      kvs.reject! { |key, _| key.nil? || key.empty? }
+      logger.debug { "[#{self.class}/#{__method__}] Parsed kvs #{kvs.inspect}" }
 
       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' }
+            logger.debug { "[#{self.class}/#{__method__}] invalid trace option for trigger trace: value=#{v}, already_set=#{trace_options.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' }
+            logger.debug { "[#{self.class}/#{__method__}] invalid trace option for timestamp: value=#{v}, already_set=#{trace_options.timestamp}" }
             trace_options.ignored << [k, v]
             next
           end
 
           unless numeric_integer?(v)
-            logger.debug { 'invalid trace option for timestamp, should be an integer' }
+            logger.debug { "[#{self.class}/#{__method__}] invalid trace option for timestamp, should be an integer: #{v}" }
             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' }
+            logger.debug { "[#{self.class}/#{__method__}] invalid trace option for sw keys: value=#{v}, already_set=#{trace_options.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}" }
+            logger.debug { "[#{self.class}/#{__method__}] invalid trace option for custom key #{k}: value=#{v}, already_set=#{trace_options.custom[k]}" }
             trace_options.ignored << [k, v]
             next
           end
           trace_options.custom[k] = v
         else
+          logger.debug { "[#{self.class}/#{__method__}] Unknown key ignored: #{k}=#{v}" }
           trace_options.ignored << [k, v]
         end
       end
-
+      logger.debug { "[#{self.class}/#{__method__}] Parsing complete: trigger_trace=#{trace_options.trigger_trace}, timestamp=#{trace_options.timestamp}, sw_keys=#{trace_options.sw_keys}, custom_keys=#{trace_options.custom}, ignored=#{trace_options.ignored}" }
       trace_options
     end
 
@@ -86,15 +89,29 @@ module SolarWindsAPM
         '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(';')
+
+      kvs.compact!
+      result = kvs.map { |k, v| "#{k}:#{v}" }.join(';')
+      SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] Stringified trace options response: #{result}" }
+      result
     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
+      unless key
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] Signature validation failed: no signature key available" }
+        return Auth::NO_SIGNATURE_KEY
+      end
+
+      unless timestamp && (Time.now.to_i - timestamp).abs <= 5 * 60
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] Signature validation failed: bad timestamp (diff more than 300s)" }
+        return Auth::BAD_TIMESTAMP
+      end
 
       digest = OpenSSL::HMAC.hexdigest('SHA1', key, header)
-      signature == digest ? Auth::OK : Auth::BAD_SIGNATURE
+      is_valid = signature == digest
+
+      SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] Signature validation result: #{is_valid ? 'valid' : 'invalid'}" }
+      is_valid ? Auth::OK : Auth::BAD_SIGNATURE
     end
   end
 end

data/lib/solarwinds_apm/sampling.rb

@@ -10,7 +10,6 @@ require 'json'
 require 'fileutils'
 require 'tempfile'
 require 'uri'
-require 'opentelemetry-sdk'
 
 require_relative 'sampling/sampling_constants'
 require_relative 'sampling/dice'