solarwinds_apm 5.1.9 → 6.0.0.preV2

data/lib/solarwinds_apm/opentelemetry/solarwinds_propagator.rb

@@ -0,0 +1,92 @@
+module SolarWindsAPM
+  module OpenTelemetry
+    module SolarWindsPropagator
+      # TextMapPropagator
+      class TextMapPropagator
+        TRACESTATE_HEADER_NAME    = "tracestate".freeze
+        XTRACEOPTIONS_HEADER_NAME = "x-trace-options".freeze
+        XTRACEOPTIONS_SIGNATURE_HEADER_NAME = "x-trace-options-signature".freeze
+        INTL_SWO_X_OPTIONS_KEY    = "sw_xtraceoptions".freeze
+        INTL_SWO_SIGNATURE_KEY    = "sw_signature".freeze
+
+        private_constant \
+          :TRACESTATE_HEADER_NAME, :XTRACEOPTIONS_HEADER_NAME, 
+          :XTRACEOPTIONS_SIGNATURE_HEADER_NAME, :INTL_SWO_X_OPTIONS_KEY, :INTL_SWO_SIGNATURE_KEY
+
+        # Extract trace context from the supplied carrier.
+        #
+        # @param [Carrier] carrier The carrier to get the header from
+        # @param [optional Context] context Context to be updated with the trace context
+        #   extracted from the carrier. Defaults to +Context.current+.
+        # @param [optional Getter] getter If the optional getter is provided, it
+        #   will be used to read the header from the carrier, otherwise the default
+        #   text map getter will be used.
+        #
+        # @return [Context] context updated with extracted baggage, or the original context
+        #   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?}"}
+
+          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
+        end
+
+        # Inject trace context into the supplied carrier.
+        #
+        # @param [Carrier] carrier The mutable carrier to inject trace context into
+        # @param [Context] context The context to read trace context from
+        # @param [optional Setter] setter If the optional setter is provided, it
+        #   will be used to write context into the carrier, otherwise the default
+        #   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__}] 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}"}
+          return unless span_context&.valid?
+
+          sw_value = Transformer.sw_from_context(span_context)  # sw_value is a string
+          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
+          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}"}
+          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}"}
+          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
+        # should delete the fields returned by this method before calling +inject+.
+        #
+        # @return [Array<String>] a list of fields that will be used by this propagator.
+        def fields
+          TRACESTATE_HEADER_NAME
+        end
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/opentelemetry/solarwinds_response_propagator.rb

@@ -0,0 +1,72 @@
+module SolarWindsAPM
+  module OpenTelemetry
+    module SolarWindsResponsePropagator
+      # ResponsePropagator
+      class TextMapPropagator
+        HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS = "Access-Control-Expose-Headers".freeze
+        XTRACE_HEADER_NAME                        = "x-trace".freeze
+        XTRACEOPTIONS_RESPONSE_HEADER_NAME        = "x-trace-options-response".freeze
+        INTL_SWO_EQUALS                           = "=".freeze
+
+        private_constant \
+          :HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS, :XTRACE_HEADER_NAME, 
+          :XTRACEOPTIONS_RESPONSE_HEADER_NAME
+
+        def extract(carrier, context: ::OpenTelemetry::Context.current, getter: ::OpenTelemetry::Context::Propagation.text_map_getter) # rubocop:disable Lint/UnusedMethodArgument
+          context
+        end
+
+        # Inject trace context into the supplied carrier.
+        #
+        # @param [Carrier] carrier The mutable carrier to inject trace context into
+        # @param [Context] context The context to read trace context from
+        # @param [optional Setter] setter If the optional setter is provided, it
+        #   will be used to write context into the carrier, otherwise the default
+        #   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?
+          
+          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}"}
+          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__}] response propagator exposed_headers: #{exposed_headers.inspect}"}
+          setter.set(carrier, HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS, exposed_headers.join(","))
+
+        end
+
+        # Returns the predefined propagation fields. If your carrier is reused, you
+        # should delete the fields returned by this method before calling +inject+.
+        #
+        # @return [Array<String>] a list of fields that will be used by this propagator.
+        def fields
+          TRACESTATE_HEADER_NAME
+        end
+
+        private
+
+        # sw_xtraceoptions_response_key -> xtrace_options_response
+        def recover_response_from_tracestate(tracestate)
+          sanitized = tracestate.value(XTraceOptions.sw_xtraceoptions_response_key)
+          sanitized = "" if sanitized.nil?
+          sanitized = sanitized.gsub(SolarWindsAPM::Constants::INTL_SWO_EQUALS_W3C_SANITIZED, SolarWindsAPM::Constants::INTL_SWO_EQUALS)
+          sanitized = sanitized.gsub(SolarWindsAPM::Constants::INTL_SWO_COMMA_W3C_SANITIZED, SolarWindsAPM::Constants::INTL_SWO_COMMA)
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] recover_response_from_tracestate sanitized: #{sanitized.inspect}"}
+          sanitized
+        end
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/opentelemetry/solarwinds_sampler.rb

@@ -0,0 +1,335 @@
+module SolarWindsAPM
+  module OpenTelemetry
+    # SolarWindsSampler
+    class SolarWindsSampler
+      INTERNAL_BUCKET_CAPACITY   = "BucketCapacity".freeze
+      INTERNAL_BUCKET_RATE       = "BucketRate".freeze
+      INTERNAL_SAMPLE_RATE       = "SampleRate".freeze
+      INTERNAL_SAMPLE_SOURCE     = "SampleSource".freeze
+      INTERNAL_SW_KEYS           = "SWKeys".freeze
+      LIBOBOE_CONTINUED          = -1
+      SW_TRACESTATE_CAPTURE_KEY  = "sw.w3c.tracestate".freeze
+      SW_TRACESTATE_ROOT_KEY     = "sw.tracestate_parent_id".freeze
+      UNSET                      = -1
+      SWO_TRACING_ENABLED        = 1
+      SWO_TRACING_DISABLED       = 0
+      SWO_TRACING_UNSET          = -1
+      XTRACEOPTIONS_RESP_AUTH    = "auth".freeze
+      XTRACEOPTIONS_RESP_IGNORED = "ignored".freeze
+      XTRACEOPTIONS_RESP_TRIGGER_IGNORED       = "ignored".freeze
+      XTRACEOPTIONS_RESP_TRIGGER_NOT_REQUESTED = "not-requested".freeze
+      XTRACEOPTIONS_RESP_TRIGGER_TRACE         = "trigger-trace".freeze
+
+      attr_reader :description
+
+      def initialize(config={})
+        @config = config
+      end
+
+      def ==(other)
+        @decision == other.decision && @description == other.description
+      end
+
+      # @api private
+      #
+      # See {Samplers}.
+      # trace_id
+      # parent_context: OpenTelemetry::Context
+      def should_sample?(trace_id:, parent_context:, links:, name:, kind:, attributes:)
+
+        SolarWindsAPM.logger.debug do 
+          "[#{self.class}/#{__method__}] should_sample? parameters \n
+                                        trace_id: #{trace_id.unpack1('H*')}\n
+                                        parent_context:  #{parent_context}\n
+                                        parent_context.inspect:  #{parent_context.inspect}\n
+                                        links: #{links}\n
+                                        name: #{name}\n
+                                        kind: #{kind}\n
+                                        attributes: #{attributes}"
+        end
+
+        # if the upstream has tracestate: sw=.... then it should capture it 
+
+        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}"}
+        
+        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}"}
+
+        sampling_result
+      end
+
+      protected
+
+      attr_reader :decision
+
+      private
+
+      # return 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}"}
+
+        # 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}."}
+          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
+
+        SolarWindsAPM.logger.debug do 
+          "[#{self.class}/#{__method__}] decision parameters \n
+                                         tracestring: #{tracestring}\n
+                                         sw_member_value: #{sw_member_value}\n
+                                         tracing_mode:    #{tracing_mode}\n
+                                         sample_rate:     #{sample_rate}\n
+                                         trigger_trace:   #{trigger_trace}\n
+                                         trigger_trace_mode:    #{trigger_trace_mode}\n
+                                         options:      #{options}\n
+                                         signature:    #{signature}\n
+                                         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)
+
+        decision = {}
+        decision["do_metrics"]    = do_metrics > 0
+        decision["do_sample"]     = do_sample > 0 
+        decision["rate"]          = rate
+        decision["source"]        = source
+        decision["bucket_rate"]   = bucket_rate
+        decision["bucket_cap"]    = bucket_cap
+        decision["decision_type"] = decision_type
+        decision["auth"]          = auth
+        decision["status_msg"]    = status_msg
+        decision["auth_msg"]      = auth_msg
+        decision["status"]        = status
+        decision
+      end
+
+      def otel_decision_from_liboboe(liboboe_decision)
+
+        decision = ::OpenTelemetry::SDK::Trace::Samplers::Decision::DROP
+        if liboboe_decision["do_sample"]
+          decision = ::OpenTelemetry::SDK::Trace::Samplers::Decision::RECORD_AND_SAMPLE  # even if not do_metrics
+        elsif liboboe_decision["do_metrics"]
+          decision = ::OpenTelemetry::SDK::Trace::Samplers::Decision::RECORD_ONLY
+        end
+        SolarWindsAPM.logger.debug {"OTel decision created: #{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}"}
+        if !parent_span_context.valid?
+          
+          trace_state = create_new_trace_state(parent_span_context, 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
+        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))
+        end
+
+        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}"        }
+
+        # 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)
+        
+        else
+          # Must retain all potential tracestate pairs for attributes
+          attr_trace_state = ::OpenTelemetry::Trace::Tracestate.from_string(tracestate_capture)
+
+          # 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)
+        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
+      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 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}
+
+        # Always (root or is_remote) set _INTERNAL_SW_KEYS if injected
+        new_attributes[INTERNAL_SW_KEYS] = xtraceoptions.sw_keys if xtraceoptions.sw_keys
+
+        # Always (root or is_remote) set custom KVs if extracted from x-trace-options
+        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}"}
+
+        # 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?
+
+        # If unsigned or signed TT (root or is_remote), set TriggeredTrace
+        new_attributes[SolarWindsAPM::Constants::INTERNAL_TRIGGERED_TRACE] = true if xtraceoptions.trigger_trace
+
+        # Trace's root span has no valid traceparent nor tracestate so we can't calculate remaining attributes
+        if !parent_span_context.valid? || trace_state.nil?
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] No valid traceparent or no tracestate - returning attributes: #{new_attributes}"}
+          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.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)
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/opentelemetry.rb

@@ -0,0 +1,8 @@
+require 'opentelemetry/sdk'
+require 'opentelemetry/instrumentation/all'
+
+require_relative './opentelemetry/solarwinds_propagator'
+require_relative './opentelemetry/solarwinds_processor'
+require_relative './opentelemetry/solarwinds_sampler'
+require_relative './opentelemetry/solarwinds_exporter'
+require_relative './opentelemetry/solarwinds_response_propagator'

data/lib/solarwinds_apm/otel_config.rb

@@ -0,0 +1,161 @@
+module SolarWindsAPM
+  # OTelConfig module
+  # For configure otel component: configurable: propagator, exporter
+  #                               non-config: sampler, processor, response_propagator
+  # Level of this configuration: SolarWindsOTel::Config -> OboeOption -> SolarWindsOTel::OTelConfig
+  module OTelConfig
+    @@config           = {}
+    @@config_map       = {}
+    
+    @@agent_enabled    = true
+
+    def self.disable_agent
+      return unless @@agent_enabled  # only show the msg once
+      
+      @@agent_enabled = false
+      SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] Agent disabled. No Trace exported."}
+    end
+
+    def self.validate_service_key
+      return unless (ENV['SW_APM_REPORTER'] || 'ssl') == 'ssl'
+
+      disable_agent unless ENV['SW_APM_SERVICE_KEY'] || SolarWindsAPM::Config[:service_key]
+    end
+
+    def self.resolve_sampler
+
+      resolve_sampler_config
+      @@config[:sampler] = 
+        ::OpenTelemetry::SDK::Trace::Samplers.parent_based(
+          root: SolarWindsAPM::OpenTelemetry::SolarWindsSampler.new(@@config[:sampler_config]),
+          remote_parent_sampled: SolarWindsAPM::OpenTelemetry::SolarWindsSampler.new(@@config[:sampler_config]),
+          remote_parent_not_sampled: SolarWindsAPM::OpenTelemetry::SolarWindsSampler.new(@@config[:sampler_config]))
+    end
+
+    def self.resolve_sampler_config      
+      sampler_config = {}
+      sampler_config["trigger_trace"] = "enabled" 
+      sampler_config["trigger_trace"] = nil if ENV["SW_APM_TRIGGER_TRACING_MODE"] == 'disabled'
+      @@config[:sampler_config] = sampler_config
+    end
+
+    #
+    # append/add solarwinds_response_propagator into rack instrumentation
+    # 
+    def self.resolve_for_response_propagator
+      response_propagator = SolarWindsAPM::OpenTelemetry::SolarWindsResponsePropagator::TextMapPropagator.new
+      if @@config_map["OpenTelemetry::Instrumentation::Rack"]
+        if @@config_map["OpenTelemetry::Instrumentation::Rack"][:response_propagators].instance_of?(Array)
+          @@config_map["OpenTelemetry::Instrumentation::Rack"][:response_propagators].append(response_propagator)
+        else
+          @@config_map["OpenTelemetry::Instrumentation::Rack"][:response_propagators] = [response_propagator]
+        end
+      else
+        @@config_map["OpenTelemetry::Instrumentation::Rack"] = {response_propagators: [response_propagator]}
+      end
+    end
+
+    def self.[](key)
+      @@config[key.to_sym]
+    end
+
+    def self.print_config
+      @@config.each do |config, value|
+        SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] config:     #{config} = #{value}"}
+      end
+      @@config_map.each do |config, value|
+        SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] config_map: #{config} = #{value}"}
+      end
+    end
+
+    def self.resolve_solarwinds_processor
+      txn_manager = SolarWindsAPM::OpenTelemetry::TxnNameManager.new
+      exporter    = SolarWindsAPM::OpenTelemetry::SolarWindsExporter.new(txn_manager: txn_manager)
+      @@config[:span_processor] = SolarWindsAPM::OpenTelemetry::SolarWindsProcessor.new(exporter, txn_manager)
+    end
+
+    def self.resolve_solarwinds_propagator
+      @@config[:propagators] = SolarWindsAPM::OpenTelemetry::SolarWindsPropagator::TextMapPropagator.new
+    end
+
+    def self.validate_propagator(propagators)
+      if propagators.nil?
+        disable_agent
+        return
+      end
+
+      SolarWindsAPM.logger.debug {"[#{name}/#{__method__}] propagators: #{propagators.map(&:class)}"}
+      unless ([::OpenTelemetry::Trace::Propagation::TraceContext::TextMapPropagator, ::OpenTelemetry::Baggage::Propagation::TextMapPropagator] - propagators.map(&:class)).empty? # rubocop:disable Style/GuardClause
+        SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] Missing tracecontext propagator."}
+        disable_agent
+      end
+    end
+
+    def self.initialize
+      unless defined?(::OpenTelemetry::SDK::Configurator)
+        SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] missing OpenTelemetry::SDK::Configurator; opentelemetry seems not loaded."}
+        disable_agent
+        return
+      end
+
+      validate_service_key
+
+      return unless @@agent_enabled
+
+      resolve_sampler
+      
+      resolve_solarwinds_propagator
+      resolve_solarwinds_processor
+      resolve_for_response_propagator
+
+      print_config if SolarWindsAPM.logger.level.zero?
+
+      ENV['OTEL_TRACES_EXPORTER'] = 'none' if ENV['OTEL_TRACES_EXPORTER'].nil?
+      ::OpenTelemetry::SDK.configure do |c|
+        c.use_all(@@config_map)
+      end
+      
+      validate_propagator(::OpenTelemetry.propagation.instance_variable_get(:@propagators))
+
+      return unless @@agent_enabled
+
+      # append our propagators
+      ::OpenTelemetry.propagation.instance_variable_get(:@propagators).append(@@config[:propagators]) 
+      
+      # append our processors (with our exporter)      
+      ::OpenTelemetry.tracer_provider.add_span_processor(@@config[:span_processor])
+      
+      # configure sampler afterwards
+      ::OpenTelemetry.tracer_provider.sampler = @@config[:sampler]
+      nil
+    end
+
+    # 
+    # Allow initialize after set new value to SolarWindsAPM::Config[:key]=value
+    # 
+    # Usage:
+    # 
+    # Default using the use_all to load all instrumentation 
+    # But with specific instrumentation disabled, use {:enabled: false} in config
+    # SolarWindsAPM::OTelConfig.initialize_with_config do |config|
+    #   config["OpenTelemetry::Instrumentation::Rack"]  = {"a" => "b"}
+    #   config["OpenTelemetry::Instrumentation::Dalli"] = {:enabled: false}
+    # end
+    #
+    def self.initialize_with_config
+      unless block_given?
+        SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] Block not given while doing in-code configuration. Agent disabled."}
+        return
+      end
+
+      yield @@config_map
+
+      if @@config_map.empty?
+        SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] No configuration given for in-code configuration. Agent disabled."}
+        return
+      end
+
+      initialize
+    end
+  end
+end