solarwinds_apm 6.0.0.preV2 → 6.0.0.preV4

data/lib/solarwinds_apm/opentelemetry/solarwinds_processor.rb

@@ -32,11 +32,9 @@ module SolarWindsAPM
         return if parent_span && parent_span.context != ::OpenTelemetry::Trace::SpanContext::INVALID && parent_span.context.remote? == false
 
         trace_flags = span.context.trace_flags.sampled? ? '01' : '00'
-        ::OpenTelemetry::Context.attach(::OpenTelemetry::Baggage.set_value(::SolarWindsAPM::Constants::INTL_SWO_CURRENT_TRACE_ID, span.context.hex_trace_id))
-        ::OpenTelemetry::Context.attach(::OpenTelemetry::Baggage.set_value(::SolarWindsAPM::Constants::INTL_SWO_CURRENT_SPAN_ID, span.context.hex_span_id))
-        ::OpenTelemetry::Context.attach(::OpenTelemetry::Baggage.set_value(::SolarWindsAPM::Constants::INTL_SWO_CURRENT_TRACE_FLAG, trace_flags))
-        
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] current baggage values: #{::OpenTelemetry::Baggage.values}"}
+        @txn_manager.set_root_context_h(span.context.hex_trace_id,"#{span.context.hex_span_id}-#{trace_flags}")
+      rescue StandardError => e
+        SolarWindsAPM.logger.info {"[#{self.class}/#{__method__}] processor on_start error: #{e.message}"}
       end
 
       # Called when a {Span} is ended, if the {Span#recording?}
@@ -47,7 +45,9 @@ module SolarWindsAPM
       # Only calculate inbound metrics for service root spans
       #
       # @param [Span] span the {Span} that just ended.
-      def on_finish(span) 
+      def on_finish(span)
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] processor on_finish span: #{span.inspect}"}
+
         if span.parent_span_id != ::OpenTelemetry::Trace::INVALID_SPAN_ID 
           @exporter&.export([span.to_span_data]) if span.context.trace_flags.sampled?
           return
@@ -57,12 +57,10 @@ module SolarWindsAPM
         domain     = nil
         has_error  = error?(span)
         trans_name = calculate_transaction_names(span)
-        url_tran   = span.attributes[HTTP_URL]
-
-        liboboe_txn_name = nil
         if span_http?(span)
-          status_code = get_http_status_code(span)
+          status_code    = get_http_status_code(span)
           request_method = span.attributes[HTTP_METHOD]
+          url_tran       = span.attributes[HTTP_URL]
 
           SolarWindsAPM.logger.debug do 
             "[#{self.class}/#{__method__}] createHttpSpan with\n
@@ -92,8 +90,11 @@ module SolarWindsAPM
 
         SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] liboboe_txn_name: #{liboboe_txn_name}"}
         @txn_manager["#{span.context.hex_trace_id}-#{span.context.hex_span_id}"] = liboboe_txn_name if span.context.trace_flags.sampled?
-
+        @txn_manager.delete_root_context_h(span.context.hex_trace_id)
         @exporter&.export([span.to_span_data]) if span.context.trace_flags.sampled?
+      rescue StandardError => e
+        SolarWindsAPM.logger.info {"[#{self.class}/#{__method__}] can't flush span to exporter; processor on_finish error: #{e.message}"}
+        ::OpenTelemetry::SDK::Trace::Export::FAILURE
       end
 
       # Export all ended spans to the configured `Exporter` that have not yet
@@ -108,7 +109,7 @@ module SolarWindsAPM
       # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
       #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
       def force_flush(timeout: nil)
-        @exporter&.force_flush(timeout: timeout) || ::OpenTelemetry::SDK::Metrics::Export::SUCCESS
+        @exporter&.force_flush(timeout: timeout) || ::OpenTelemetry::SDK::Trace::Export::SUCCESS
       end
 
       # Called when {TracerProvider#shutdown} is called.
@@ -117,14 +118,13 @@ module SolarWindsAPM
       # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
       #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
       def shutdown(timeout: nil)
-        @exporter&.shutdown(timeout: timeout) || ::OpenTelemetry::SDK::Metrics::Export::SUCCESS
+        @exporter&.shutdown(timeout: timeout) || ::OpenTelemetry::SDK::Trace::Export::SUCCESS
       end
 
       private
 
       # This span from inbound HTTP request if from a SERVER by some http.method
       def span_http?(span)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] span.kind #{span.kind}  span.attributes: #{span.attributes[HTTP_METHOD]}"}
         (span.kind == ::OpenTelemetry::Trace::SpanKind::SERVER && !span.attributes[HTTP_METHOD].nil?)
       end
 
@@ -143,10 +143,11 @@ module SolarWindsAPM
 
       # Get trans_name and url_tran of this span instance.
       def calculate_transaction_names(span)
-
         trace_span_id = "#{span.context.hex_trace_id}-#{span.context.hex_span_id}"
-        if @txn_manager.get(trace_span_id)
-          trans_name = @txn_manager.get(trace_span_id)
+        trans_name = @txn_manager.get(trace_span_id)
+        if trans_name
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] found trans name from txn_manager: #{trans_name} by #{trace_span_id}"}
+          @txn_manager.del(trace_span_id)
         else
           trans_name = span.attributes[HTTP_ROUTE] || nil
           trans_name = span.name if span.name && (trans_name.nil? || trans_name.empty?)

data/lib/solarwinds_apm/opentelemetry/solarwinds_propagator.rb

@@ -2,6 +2,7 @@ module SolarWindsAPM
   module OpenTelemetry
     module SolarWindsPropagator
       # TextMapPropagator
+      # propagator error will be rescued by OpenTelemetry::Context::Propagation::TextMapPropagator
       class TextMapPropagator
         TRACESTATE_HEADER_NAME    = "tracestate".freeze
         XTRACEOPTIONS_HEADER_NAME = "x-trace-options".freeze
@@ -26,19 +27,11 @@ module SolarWindsAPM
         #   if extraction fails
         def extract(carrier, context: ::OpenTelemetry::Context.current, getter: ::OpenTelemetry::Context::Propagation.text_map_getter)
 
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] context(before): #{context.inspect} #{context.nil?}"}
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] extract context: #{context.inspect}"}
 
-          context = ::OpenTelemetry::Context.new({}) if context.nil?
-
-          xtraceoptions_header = getter.get(carrier, XTRACEOPTIONS_HEADER_NAME)
-          context = context.set_value(INTL_SWO_X_OPTIONS_KEY, xtraceoptions_header) if xtraceoptions_header
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] xtraceoptions_header: #{xtraceoptions_header}"}
-
-          signature_header = getter.get(carrier, XTRACEOPTIONS_SIGNATURE_HEADER_NAME)
-          context = context.set_value(INTL_SWO_SIGNATURE_KEY, signature_header) if signature_header
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] signature_header: #{signature_header}; propagator extract context: #{context.inspect}"}
-
-          context
+          context = context.nil?? ::OpenTelemetry::Context.new({}) : context
+          context = inject_extracted_header(carrier, context, getter, XTRACEOPTIONS_HEADER_NAME, INTL_SWO_X_OPTIONS_KEY)
+          inject_extracted_header(carrier, context, getter, XTRACEOPTIONS_SIGNATURE_HEADER_NAME, INTL_SWO_SIGNATURE_KEY)
         end
 
         # Inject trace context into the supplied carrier.
@@ -51,32 +44,30 @@ module SolarWindsAPM
         def inject(carrier, context: ::OpenTelemetry::Context.current, setter: ::OpenTelemetry::Context::Propagation.text_map_setter)
 
           SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] inject context: #{context.inspect}"}
-          
-          cspan = ::OpenTelemetry::Trace.current_span(context)
-          span_context = cspan&.context
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] cspan #{cspan.inspect}; span_context #{span_context.inspect}"}
+        
+          span_context = ::OpenTelemetry::Trace.current_span(context)&.context
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] span_context #{span_context.inspect}"}
           return unless span_context&.valid?
 
-          sw_value = Transformer.sw_from_context(span_context)  # sw_value is a string
+          trace_flag = span_context.trace_flags.sampled?? 1 : 0
+          sw_value   = "#{span_context.hex_span_id}-0#{trace_flag}"
           trace_state_header = carrier[TRACESTATE_HEADER_NAME].nil?? nil : carrier[TRACESTATE_HEADER_NAME]
-
           SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] sw_value: #{sw_value}; trace_state_header: #{trace_state_header}"}
 
-          # Prepare carrier with carrier's or new tracestate
-          trace_state = nil
+          # prepare carrier with carrier's or new tracestate
           if trace_state_header.nil?
-            # Only create new trace state if valid span_id
-            return if span_context.span_id == ::OpenTelemetry::Trace::INVALID_SPAN_ID
-              
-            trace_state = ::OpenTelemetry::Trace::Tracestate.create({SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY => sw_value})
-            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] creating new trace state: #{trace_state.inspect}"}
+            # only create new trace state if valid span_id
+            unless span_context.span_id == ::OpenTelemetry::Trace::INVALID_SPAN_ID
+              trace_state = ::OpenTelemetry::Trace::Tracestate.create({SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY => sw_value})
+              SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] creating new trace state: #{trace_state.inspect}"}
+              setter.set(carrier, TRACESTATE_HEADER_NAME, Utils.trace_state_header(trace_state))
+            end
           else
             trace_state_from_string = ::OpenTelemetry::Trace::Tracestate.from_string(trace_state_header)
             trace_state = trace_state_from_string.set_value(SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY, sw_value)
-            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Updating/Adding trace state for injection #{trace_state.inspect}"}
+            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] updating/adding trace state for injection #{trace_state.inspect}"}
+            setter.set(carrier, TRACESTATE_HEADER_NAME, Utils.trace_state_header(trace_state))
           end
-
-          setter.set(carrier, TRACESTATE_HEADER_NAME, Transformer.trace_state_header(trace_state))
         end
 
         # Returns the predefined propagation fields. If your carrier is reused, you
@@ -86,6 +77,15 @@ module SolarWindsAPM
         def fields
           TRACESTATE_HEADER_NAME
         end
+
+        private
+        
+        def inject_extracted_header(carrier, context, getter, header, inject_key)
+          extracted_header = getter.get(carrier, header)
+          context = context.set_value(inject_key, extracted_header) if extracted_header
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] #{header}: #{inject_key} = #{extracted_header}"}
+          context
+        end
       end
     end
   end

data/lib/solarwinds_apm/opentelemetry/solarwinds_response_propagator.rb

@@ -2,6 +2,7 @@ module SolarWindsAPM
   module OpenTelemetry
     module SolarWindsResponsePropagator
       # ResponsePropagator
+      # response propagator error will be rescued by OpenTelemetry::Instrumentation::Rack::Middlewares::EventHandler
       class TextMapPropagator
         HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS = "Access-Control-Expose-Headers".freeze
         XTRACE_HEADER_NAME                        = "x-trace".freeze
@@ -25,26 +26,20 @@ module SolarWindsAPM
         #   text map setter will be used.
         def inject(carrier, context: ::OpenTelemetry::Context.current, setter: ::OpenTelemetry::Context::Propagation.text_map_setter)
 
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] response propagator context: #{context.inspect}"}
           span_context = ::OpenTelemetry::Trace.current_span(context).context
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] response propagator span_context: #{span_context.inspect}"}
-          return unless span_context.valid?
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] context: #{context.inspect}; span_context: #{span_context.inspect}"}
+          return unless span_context&.valid?
           
-          x_trace = Transformer.traceparent_from_context(span_context)
-          setter.set(carrier, XTRACE_HEADER_NAME, x_trace)
-          exposed_headers = [XTRACE_HEADER_NAME]
-
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] response propagator span_context.tracestate: #{span_context.tracestate.inspect}"}
+          x_trace                = Utils.traceparent_from_context(span_context)
+          exposed_headers        = [XTRACE_HEADER_NAME]
           xtraceoptions_response = recover_response_from_tracestate(span_context.tracestate)
 
-          unless xtraceoptions_response.empty?
-            exposed_headers << XTRACEOPTIONS_RESPONSE_HEADER_NAME
-            setter.set(carrier, XTRACEOPTIONS_RESPONSE_HEADER_NAME, xtraceoptions_response)
-          end
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] x-trace: #{x_trace}; exposed headers: #{exposed_headers.inspect}; x-trace-options-response: #{xtraceoptions_response}"}
+          exposed_headers.append(XTRACEOPTIONS_RESPONSE_HEADER_NAME) unless xtraceoptions_response.empty?
 
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] response propagator exposed_headers: #{exposed_headers.inspect}"}
+          setter.set(carrier, XTRACE_HEADER_NAME, x_trace)
+          setter.set(carrier, XTRACEOPTIONS_RESPONSE_HEADER_NAME, xtraceoptions_response) unless xtraceoptions_response.empty?
           setter.set(carrier, HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS, exposed_headers.join(","))
-
         end
 
         # Returns the predefined propagation fields. If your carrier is reused, you

data/lib/solarwinds_apm/opentelemetry/solarwinds_sampler.rb

@@ -38,7 +38,7 @@ module SolarWindsAPM
       def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
 
         SolarWindsAPM.logger.debug do 
-          "[#{self.class}/#{__method__}] should_sample? parameters \n
+          "[#{self.class}/#{__method__}] should_sample? start parameters \n
                                         trace_id: #{trace_id.unpack1('H*')}\n
                                         parent_context:  #{parent_context}\n
                                         parent_context.inspect:  #{parent_context.inspect}\n
@@ -48,30 +48,25 @@ module SolarWindsAPM
                                         attributes: #{attributes}"
         end
 
-        # if the upstream has tracestate: sw=.... then it should capture it 
+        parent_span_context = ::OpenTelemetry::Trace.current_span(parent_context).context        
+        xtraceoptions       = ::SolarWindsAPM::XTraceOptions.new(parent_context)
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] parent_span_context: #{parent_span_context.inspect}\n xtraceoptions: #{xtraceoptions.inspect}"}
 
-        parent_span_context = ::OpenTelemetry::Trace.current_span(parent_context).context
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] should_sample? parent_span_context: #{parent_span_context.inspect}"}
-        
-        xtraceoptions       = SolarWindsAPM::XTraceOptions.new(parent_context)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] xtraceoptions: #{xtraceoptions.inspect}"}
-        
         liboboe_decision    = calculate_liboboe_decision(parent_span_context, xtraceoptions, name, kind, attributes)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] liboboe_decision: #{liboboe_decision.inspect}"}
-
-        otel_decision   = otel_decision_from_liboboe(liboboe_decision)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] otel_decision: #{otel_decision.inspect}"}
-
-        new_trace_state = calculate_trace_state(liboboe_decision,parent_span_context,xtraceoptions)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] new_trace_state: #{new_trace_state.inspect}"}
-
-        new_attributes  = calculate_attributes(attributes,liboboe_decision,new_trace_state,parent_span_context,xtraceoptions)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] new_attributes: #{new_attributes.inspect}"}
+        otel_decision       = otel_decision_from_liboboe(liboboe_decision)
+        new_trace_state     = calculate_trace_state(liboboe_decision, parent_span_context, xtraceoptions)
+        new_attributes      = otel_sampled?(otel_decision)? calculate_attributes(attributes, liboboe_decision, new_trace_state, parent_span_context, xtraceoptions) : nil
+        sampling_result     = ::OpenTelemetry::SDK::Trace::Samplers::Result.new(decision: otel_decision, 
+                                                                                attributes: new_attributes, 
+                                                                                tracestate: new_trace_state)
         
-        sampling_result = ::OpenTelemetry::SDK::Trace::Samplers::Result.new(decision: otel_decision, attributes: new_attributes, tracestate: new_trace_state)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] sampling_result: #{sampling_result.inspect}"}
-
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] should_sample? end with sampling_result: #{sampling_result.inspect} from otel_decision: #{otel_decision.inspect} and new_attributes: #{new_attributes.inspect}"}
         sampling_result
+      rescue StandardError => e
+        SolarWindsAPM.logger.info {"[#{self.class}/#{__method__}] sampler error: #{e.message}"}
+        ::OpenTelemetry::SDK::Trace::Samplers::Result.new(decision: ::OpenTelemetry::SDK::Trace::Samplers::Decision::DROP, 
+                                                          attributes: attributes, 
+                                                          tracestate: ::OpenTelemetry::Trace::Tracestate::DEFAULT)
       end
 
       protected
@@ -80,51 +75,36 @@ module SolarWindsAPM
 
       private
 
-      # return Hash
+      ##
+      # use parent_span_context and xtraceoptions object to feed to liboboe function getDecisions that get liboboe_decision
+      # name, kind and attributes are used for transaction filter caching (to avoid continous calculate_trace_mode calculation)
+      # return decision Hash
       def calculate_liboboe_decision(parent_span_context, xtraceoptions, name, kind, attributes)
-
-        tracestring = nil
-        if parent_span_context.valid? && parent_span_context.remote?
-          tracestring = Transformer.traceparent_from_context(parent_span_context)
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] calculate_liboboe_decision parent_span_context.remote? #{parent_span_context.remote?} with #{tracestring}"}
-        end
-
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] name: #{name}, kind: #{kind}, attributes: #{attributes.inspect}"}
+        tracestring = Utils.traceparent_from_context(parent_span_context) if parent_span_context.valid? && parent_span_context.remote?
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] tracestring: #{tracestring}"}
 
         # otel-ruby contrib use different key to store url info, currently it's using http.target for path
         url_path = attributes.nil?? '' : attributes['http.target']
         transaction_naming_key = "#{url_path}-#{name}-#{kind}"
-        
         tracing_mode           = SolarWindsAPM::TransactionCache.get(transaction_naming_key)
-        
-        if tracing_mode.nil?
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] transaction cache NOT found: #{transaction_naming_key}."}
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] transaction cache: #{transaction_naming_key}; tracing_mode: #{tracing_mode}."}
+
+        unless tracing_mode
           trans_settings = SolarWindsAPM::TransactionSettings.new(url_path: url_path, name: name, kind: kind)          
           tracing_mode   = trans_settings.calculate_trace_mode == 1 ? SWO_TRACING_ENABLED : SWO_TRACING_DISABLED
           SolarWindsAPM::TransactionCache.set(transaction_naming_key, tracing_mode)
-        else
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] transaction cache found: #{transaction_naming_key}."}
         end
 
         sw_member_value    = parent_span_context.tracestate[SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY]
-
-        # need to create the config class
         trigger_trace_mode = OboeTracingMode.get_oboe_trigger_trace_mode(@config["trigger_trace"])
         sample_rate        = UNSET
-
-        options = nil
-        trigger_trace = 0
-        signature = nil
-        timestamp = nil
-        if xtraceoptions
-          options = xtraceoptions.options
-          trigger_trace = xtraceoptions.intify_trigger_trace
-          signature = xtraceoptions.signature
-          timestamp = xtraceoptions.timestamp
-        end
+        options            = xtraceoptions&.options
+        trigger_trace      = xtraceoptions&.intify_trigger_trace || 0
+        signature          = xtraceoptions&.signature
+        timestamp          = xtraceoptions&.timestamp
 
         SolarWindsAPM.logger.debug do 
-          "[#{self.class}/#{__method__}] decision parameters \n
+          "[#{self.class}/#{__method__}] get liboboe decision parameters: \n
                                          tracestring: #{tracestring}\n
                                          sw_member_value: #{sw_member_value}\n
                                          tracing_mode:    #{tracing_mode}\n
@@ -136,9 +116,12 @@ module SolarWindsAPM
                                          timestamp:    #{timestamp}"
         end
 
-        args = [tracestring,sw_member_value,tracing_mode,sample_rate,trigger_trace,trigger_trace_mode,options,signature,timestamp] 
-        do_metrics, do_sample, rate, source, bucket_rate, \
-            bucket_cap, decision_type, auth, status_msg, auth_msg, status = SolarWindsAPM::Context.getDecisions(*args)
+        args = [tracestring, sw_member_value, tracing_mode, sample_rate,
+                trigger_trace, trigger_trace_mode, options, signature,timestamp]
+
+        do_metrics, do_sample, rate, source, bucket_rate,
+          bucket_cap, decision_type, auth, status_msg, auth_msg,
+            status = SolarWindsAPM::Context.getDecisions(*args)
 
         decision = {}
         decision["do_metrics"]    = do_metrics > 0
@@ -163,136 +146,78 @@ module SolarWindsAPM
         elsif liboboe_decision["do_metrics"]
           decision = ::OpenTelemetry::SDK::Trace::Samplers::Decision::RECORD_ONLY
         end
-        SolarWindsAPM.logger.debug {"OTel decision created: #{decision}"}
+        SolarWindsAPM.logger.debug {"otel decision: #{decision} created from liboboe_decision: #{liboboe_decision}"}
         decision
       end
 
-      def create_xtraceoptions_response_value(decision, parent_span_context, xtraceoptions)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] create_xtraceoptions_response_value decision[auth]: #{decision['auth']}; decision[auth_msg]: #{decision['auth_msg']}; xtraceoptions.trigger_trace: #{xtraceoptions.trigger_trace}"}
-        
-        response = []
-        w3c_sanitized = SolarWindsAPM::Constants::INTL_SWO_EQUALS_W3C_SANITIZED
-        response << [XTRACEOPTIONS_RESP_AUTH, decision['auth_msg']].join(w3c_sanitized) if xtraceoptions.signature && decision['auth_msg']
-        if !decision["auth"] || decision["auth"] < 1
-          trigger_msg = ""
-          tracestring = nil
-          if xtraceoptions.trigger_trace
-            # If a traceparent header was provided then oboe does not generate the message
-            tracestring = Transformer.traceparent_from_context(parent_span_context) if parent_span_context.valid? && parent_span_context.remote?  
-            trigger_msg = tracestring && decision['decision_type'] == 0 ? XTRACEOPTIONS_RESP_TRIGGER_IGNORED : decision['status_msg']
-          else
-            trigger_msg = XTRACEOPTIONS_RESP_TRIGGER_NOT_REQUESTED
-          end
-
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] create_xtraceoptions_response_value parent_span_context: #{parent_span_context}; tracestring: #{tracestring}; trigger_msg: #{trigger_msg}"}
-
-          # e.g. response << trigger-trace####ok
-          response << [XTRACEOPTIONS_RESP_TRIGGER_TRACE, trigger_msg].join(w3c_sanitized)
-
-        end
-
-        # so far the x-trace-options are only used for liboboe calculate decision for x-trace feature
-        # probably not need for remaining services since liboboe decision only calculate once
-        unless xtraceoptions.ignored.empty?
-          ignored_response = [XTRACEOPTIONS_RESP_IGNORED, xtraceoptions.ignored.join(SolarWindsAPM::Constants::INTL_SWO_COMMA_W3C_SANITIZED)]
-          response << ignored_response.join(w3c_sanitized)
-          # e.g. response << ignored####invalidkeys,invalidkeys,invalidkeys
-        end
-
-        response.join(';')  # e.g. trigger-trace####ok;ignored####invalidkeys,invalidkeys,invalidkeys
-      end
-
-      def create_new_trace_state(parent_span_context, decision)
-        decision = sw_from_span_and_decision(parent_span_context, decision)
-        trace_state = ::OpenTelemetry::Trace::Tracestate.from_hash({SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY => decision}) # e.g. sw=3e222c863a04123a-01
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Created new trace_state: #{trace_state.inspect}"}
-        trace_state
-      end
-
-      # 
-      # calculate_trace_state
-      # This function merely just add sw=value and xtrace_options_response=value into the old/new tracestate 
-      # The return value tracestate will be used in propagating to next services
-      # 
-      def calculate_trace_state(decision, parent_span_context, xtraceoptions)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] calculate_trace_state parent_span_context: #{parent_span_context.inspect}"}
+      ##
+      # add sw=value and xtrace_options_response=value into the old/new tracestate 
+      # the returned value tracestate will be used in propagating to next services
+      def calculate_trace_state(liboboe_decision, parent_span_context, xtraceoptions)
         if !parent_span_context.valid?
-          
-          trace_state = create_new_trace_state(parent_span_context, decision)
+          trace_state = create_new_trace_state(parent_span_context, liboboe_decision)
+        elsif parent_span_context.tracestate.nil?
+          trace_state = create_new_trace_state(parent_span_context, liboboe_decision)
         else
-
-          parent_trace_state = parent_span_context.tracestate
-          if parent_trace_state.nil?
-            trace_state = create_new_trace_state(parent_span_context, decision)
-          else
-            trace_state = parent_trace_state.set_value(SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY, sw_from_span_and_decision(parent_span_context, decision))
-            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Updated trace_state with span_id and sw trace_flags: #{trace_state.inspect}"}
-          end
+          trace_state = parent_span_context.tracestate.set_value(SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY, 
+                                                                 sw_from_span_and_decision(parent_span_context, liboboe_decision))
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] updated trace_state:  #{trace_state.inspect}"}
         end
 
         # for setting up the xtrace_options_response
         if xtraceoptions&.options
-          trace_state = trace_state.set_value(
-            XTraceOptions.sw_xtraceoptions_response_key.to_s,
-            create_xtraceoptions_response_value(decision,parent_span_context,xtraceoptions))
+          trace_state = trace_state.set_value(XTraceOptions.sw_xtraceoptions_response_key.to_s, 
+                                              create_xtraceoptions_response_value(liboboe_decision, parent_span_context, xtraceoptions)) 
         end
+        trace_state
+      end
 
+      ##
+      # 
+      def create_new_trace_state(parent_span_context, liboboe_decision)
+        decision = sw_from_span_and_decision(parent_span_context, liboboe_decision)
+        trace_state = ::OpenTelemetry::Trace::Tracestate.from_hash({SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY => decision}) # e.g. sw=3e222c863a04123a-01
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] created new trace_state: #{trace_state.inspect}"}
         trace_state
       end
 
+      ##
       #
-      # SW_TRACESTATE_CAPTURE_KEY = "sw.w3c.tracestate"
-      # sw_xtraceoptions_response_key = "xtrace_options_response"
-      # trace_state is the new trace_state from existing span information
-      # parent_span_context.trace_state is from its parent 
-      #
-      def add_tracestate_capture_to_attributes_dict(attributes_dict, decision, trace_state, parent_span_context)
-        
-        tracestate_capture = attributes_dict[SW_TRACESTATE_CAPTURE_KEY]
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] tracestate_capture #{tracestate_capture.inspect}; attributes_dict #{attributes_dict.inspect}; trace_state #{trace_state.inspect}; parent_span_context: #{parent_span_context.inspect}"        }
+      def create_xtraceoptions_response_value(liboboe_decision, parent_span_context, xtraceoptions)
 
-        # tracestate_capture seems always nil because attributes_dict never have the SW_TRACESTATE_CAPTURE_KEY (sw.w3c.tracestate)
-        # since tracestate_capture is always nil, so the sw always have new value for sw=key
-        if tracestate_capture.nil?
-          trace_state_no_response = trace_state.delete(XTraceOptions.sw_xtraceoptions_response_key)
+        response = []
+        w3c_sanitized = SolarWindsAPM::Constants::INTL_SWO_EQUALS_W3C_SANITIZED
+        w3c_sanitized_comma = SolarWindsAPM::Constants::INTL_SWO_COMMA_W3C_SANITIZED
+        response << [XTRACEOPTIONS_RESP_AUTH, liboboe_decision['auth_msg']].join(w3c_sanitized) if xtraceoptions.signature && liboboe_decision['auth_msg']
         
-        else
-          # Must retain all potential tracestate pairs for attributes
-          attr_trace_state = ::OpenTelemetry::Trace::Tracestate.from_string(tracestate_capture)
+        if !liboboe_decision["auth"] || liboboe_decision["auth"] < 1
+          if xtraceoptions.trigger_trace
+            # If a traceparent header was provided then oboe does not generate the message
+            tracestring = Utils.traceparent_from_context(parent_span_context) if parent_span_context.valid? && parent_span_context.remote?  
+            trigger_msg = tracestring && liboboe_decision['decision_type'] == 0 ? XTRACEOPTIONS_RESP_TRIGGER_IGNORED : liboboe_decision['status_msg']
+            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] tracestring: #{tracestring}; trigger_msg: #{trigger_msg}"}
+          else
+            trigger_msg = XTRACEOPTIONS_RESP_TRIGGER_NOT_REQUESTED
+          end
 
-          # This step generated the new sw=key for tracestate based on root parent_span_id
-          new_attr_trace_state = attr_trace_state.set_value(SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY, sw_from_span_and_decision(parent_span_context,decision))
-          
-          trace_state_no_response = new_attr_trace_state.delete(XTraceOptions.sw_xtraceoptions_response_key)
+          response << [XTRACEOPTIONS_RESP_TRIGGER_TRACE, trigger_msg].join(w3c_sanitized) # e.g. response << trigger-trace####ok
         end
 
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] trace_state_no_response #{trace_state_no_response.inspect}"}
-
-        # other approach
-        trace_state_no_response = parent_span_context.tracestate.delete(XTraceOptions.sw_xtraceoptions_response_key)
-        no_sw_count = trace_state_no_response.to_h.reject { |k, _v| k == "sw" }.count
-        attributes_dict[SW_TRACESTATE_CAPTURE_KEY] = Transformer.trace_state_header(trace_state_no_response) if no_sw_count > 0 
-
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] attributes_dict #{attributes_dict.inspect}"}
-        attributes_dict
+        # appending ignored value from xtraceoptions to response. e.g. response << ignored####invalidkeys,invalidkeys,invalidkeys
+        response << [XTRACEOPTIONS_RESP_IGNORED, xtraceoptions.ignored.join(w3c_sanitized_comma)].join(w3c_sanitized) unless xtraceoptions.ignored.empty?
+        joined_response = response.join(';')
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] final response_value: #{joined_response}"}
+        joined_response
       end
 
       ##
-      # calculate_attributes is used for getting the otel Result class in last step of sampler should_sample? e.g. result = Result.new(decision: otel_decision, attributes: new_attributes, tracestate: new_trace_state)
+      # calculate_attributes is used for getting the otel Result class in last step of sampler should_sample? 
+      # e.g. result = Result.new(decision: otel_decision, attributes: new_attributes, tracestate: new_trace_state)
       # calculate_attributes use new_trace_state that is derived from current span information and old tracestate from parent_span_context.tracestate
       # the sw.w3c.tracestate should perserve the old tracestate value for debugging purpose
-      ##
-      def calculate_attributes(attributes, decision, trace_state, parent_span_context, xtraceoptions)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Received attributes: #{attributes.inspect}; decision:#{decision.inspect}; trace_state:#{trace_state.inspect}; parent_span_context:#{parent_span_context.inspect}; xtraceoptions:#{xtraceoptions.inspect}"}
-
-        otel_decision = otel_decision_from_liboboe(decision)
-        return nil if Transformer.sampled?(otel_decision) == false
-        
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Trace decision is_sampled - setting attributes #{otel_decision.inspect}"}
-
-        new_attributes = {}
-        # Copy existing MappingProxyType KV into new_attributes for modification.
-        attributes&.each {|k,v| new_attributes[k] = v}
+      def calculate_attributes(attributes, liboboe_decision, trace_state, parent_span_context, xtraceoptions)
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] new_trace_state: #{trace_state.inspect}"}
+        new_attributes = attributes.dup || {}
 
         # Always (root or is_remote) set _INTERNAL_SW_KEYS if injected
         new_attributes[INTERNAL_SW_KEYS] = xtraceoptions.sw_keys if xtraceoptions.sw_keys
@@ -301,16 +226,14 @@ module SolarWindsAPM
         xtraceoptions.custom_kvs&.each {|k,v| new_attributes[k] = v}
 
         # Always (root or is_remote) set service entry internal KVs       
-        new_attributes[INTERNAL_BUCKET_CAPACITY] = decision["bucket_cap"].to_s
-        new_attributes[INTERNAL_BUCKET_RATE]     = decision["bucket_rate"].to_s
-        new_attributes[INTERNAL_SAMPLE_RATE]     = decision["rate"]
-        new_attributes[INTERNAL_SAMPLE_SOURCE]   = decision["source"]
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Set attributes with service entry internal KVs: #{new_attributes}"}
+        new_attributes[INTERNAL_BUCKET_CAPACITY] = liboboe_decision["bucket_cap"].to_s
+        new_attributes[INTERNAL_BUCKET_RATE]     = liboboe_decision["bucket_rate"].to_s
+        new_attributes[INTERNAL_SAMPLE_RATE]     = liboboe_decision["rate"]
+        new_attributes[INTERNAL_SAMPLE_SOURCE]   = liboboe_decision["source"]
 
         # set sw.tracestate_parent_id if its tracestate contains "sw"
         sw_value = parent_span_context.tracestate.value(SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] calculate_attributes sw_value: #{sw_value.inspect} parent_span_context.tracestate #{parent_span_context.tracestate.inspect}"}
-        new_attributes[SW_TRACESTATE_ROOT_KEY]= Transformer.span_id_from_sw(sw_value) if sw_value && parent_span_context.remote?
+        new_attributes[SW_TRACESTATE_ROOT_KEY] =  sw_value.split("-")[0] if sw_value && parent_span_context.remote?
 
         # If unsigned or signed TT (root or is_remote), set TriggeredTrace
         new_attributes[SolarWindsAPM::Constants::INTERNAL_TRIGGERED_TRACE] = true if xtraceoptions.trigger_trace
@@ -321,14 +244,43 @@ module SolarWindsAPM
           return new_attributes.freeze || nil
         end
 
-        new_attributes = add_tracestate_capture_to_attributes_dict(new_attributes,decision,trace_state,parent_span_context)
-        # e.g. {"SWKeys"=>"check-id:check-1013,website-id:booking-demo", "BucketCapacity"=>"6.0", "BucketRate"=>"0.1", "SampleRate"=>-1, "SampleSource"=>-1, "http.method"=>"GET", "http.host"=>"0.0.0.0:8002", "http.scheme"=>"http", "http.target"=>"/call_second_rails/", "http.user_agent"=>"curl/7.81.0", "sw.w3c.tracestate"=>"sw=aaaa1111bbbb2222-01"}
+        new_attributes = add_tracestate_capture_to_new_attributes(new_attributes, liboboe_decision, trace_state, parent_span_context)
         new_attributes.freeze
       end
 
-      def sw_from_span_and_decision(parent_span_context, decision)
-        trace_flag = Transformer.trace_flags_from_boolean(decision["do_sample"])
-        Transformer.sw_from_span_and_decision(parent_span_context.hex_span_id, trace_flag)
+      ##
+      # 
+      def add_tracestate_capture_to_new_attributes(new_attributes, liboboe_decision, trace_state, parent_span_context)
+        
+        tracestate_capture = new_attributes[SW_TRACESTATE_CAPTURE_KEY]
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] tracestate_capture #{tracestate_capture.inspect}; new_attributes #{new_attributes.inspect}"}
+
+        if tracestate_capture.nil?
+          trace_state_no_response = trace_state.delete(XTraceOptions.sw_xtraceoptions_response_key)
+        else 
+          # retain all potential tracestate pairs for attributes and generate new sw=key for tracestate based on root parent_span_id
+          attr_trace_state        = ::OpenTelemetry::Trace::Tracestate.from_string(tracestate_capture)
+          new_attr_trace_state    = attr_trace_state.set_value(SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY, sw_from_span_and_decision(parent_span_context,liboboe_decision))
+          trace_state_no_response = new_attr_trace_state.delete(XTraceOptions.sw_xtraceoptions_response_key)
+        end
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] trace_state_no_response #{trace_state_no_response.inspect}"}
+
+        trace_state_no_response = parent_span_context.tracestate.delete(XTraceOptions.sw_xtraceoptions_response_key)
+        no_sw_count             = trace_state_no_response.to_h.reject { |k, _v| k == "sw" }.count
+        new_attributes[SW_TRACESTATE_CAPTURE_KEY] = Utils.trace_state_header(trace_state_no_response) if no_sw_count > 0 
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] new_attributes after add_tracestate_capture_to_new_attributes: #{new_attributes.inspect}"}
+        
+        new_attributes
+      end
+
+      # formats tracestate sw value from span_id and liboboe decision as 16-byte span_id with 8-bit trace_flags e.g. 1a2b3c4d5e6f7g8h-01
+      def sw_from_span_and_decision(parent_span_context, liboboe_decision)
+        trace_flag = (liboboe_decision["do_sample"] == true) ? "01" : "00"
+        [parent_span_context.hex_span_id, trace_flag].join("-")
+      end
+
+      def otel_sampled?(otel_decision)
+        otel_decision == ::OpenTelemetry::SDK::Trace::Samplers::Decision::RECORD_AND_SAMPLE
       end
     end
   end