solarwinds_apm 6.1.2 → 7.0.0.prev1

data/lib/solarwinds_apm/opentelemetry/solarwinds_processor.rb

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at:http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
-
-module SolarWindsAPM
-  module OpenTelemetry
-    # reference: OpenTelemetry::SDK::Trace::SpanProcessor
-    class SolarWindsProcessor
-      HTTP_METHOD      = 'http.method'
-      HTTP_ROUTE       = 'http.route'
-      HTTP_STATUS_CODE = 'http.status_code'
-      HTTP_URL         = 'http.url'
-      LIBOBOE_HTTP_SPAN_STATUS_UNAVAILABLE = 0
-
-      attr_reader :txn_manager
-
-      def initialize(txn_manager)
-        @txn_manager = txn_manager
-      end
-
-      # Called when a {Span} is started, if the {Span#recording?}
-      # returns true.
-      #
-      # @param [Span] span the {Span} that just started.
-      # @param [Context] parent_context the parent {Context} of the newly
-      #  started span.
-      def on_start(span, parent_context)
-        SolarWindsAPM.logger.debug do
-          "[#{self.class}/#{__method__}] processor on_start span: #{span.to_span_data.inspect}, parent_context: #{parent_context.inspect}"
-        end
-
-        return if non_entry_span(parent_context: parent_context)
-
-        trace_flags = span.context.trace_flags.sampled? ? '01' : '00'
-        @txn_manager.set_root_context_h(span.context.hex_trace_id, "#{span.context.hex_span_id}-#{trace_flags}")
-        span.add_attributes({ 'sw.is_entry_span' => true })
-      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?}
-      # returns true.
-      #
-      # @param [Span] span the {Span} that just ended.
-      def on_finish(span)
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] processor on_finish span: #{span.to_span_data.inspect}" }
-
-        return if non_entry_span(span: span)
-
-        span_time  = calculate_span_time(start_time: span.start_timestamp, end_time: span.end_timestamp)
-        domain     = nil
-        has_error  = error?(span)
-        trans_name = calculate_transaction_names(span)
-        if span_http?(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
-                                          trans_name: #{trans_name}\n
-                                          url_tran: #{url_tran}\n
-                                          domain: #{domain}\n
-                                          span_time: #{span_time}\n
-                                          status_code: #{status_code}\n
-                                          request_method: #{request_method}\n
-                                          has_error: #{has_error}"
-          end
-
-          liboboe_txn_name = SolarWindsAPM::Span.createHttpSpan(trans_name, url_tran, domain, span_time, status_code,
-                                                                request_method, has_error)
-
-        else
-
-          SolarWindsAPM.logger.debug do
-            "[#{self.class}/#{__method__}] createSpan with \n
-                                          trans_name: #{trans_name}\n
-                                          domain: #{domain}\n
-                                          span_time: #{span_time}\n
-                                          has_error: #{has_error}"
-          end
-
-          liboboe_txn_name = SolarWindsAPM::Span.createSpan(trans_name, domain, span_time, has_error)
-        end
-
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] liboboe_txn_name: #{liboboe_txn_name}" }
-        if span.context.trace_flags.sampled?
-          @txn_manager["#{span.context.hex_trace_id}-#{span.context.hex_span_id}"] =
-            liboboe_txn_name
-        end
-        @txn_manager.delete_root_context_h(span.context.hex_trace_id)
-      rescue StandardError => e
-        SolarWindsAPM.logger.info do
-          "[#{self.class}/#{__method__}] solarwinds_processor on_finish error: #{e.message}"
-        end
-      end
-
-      # @param [optional Numeric] timeout An optional timeout in seconds.
-      # @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) # rubocop:disable Lint/UnusedMethodArgument
-        ::OpenTelemetry::SDK::Trace::Export::SUCCESS
-      end
-
-      # @param [optional Numeric] timeout An optional timeout in seconds.
-      # @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) # rubocop:disable Lint/UnusedMethodArgument
-        ::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)
-        span.kind == ::OpenTelemetry::Trace::SpanKind::SERVER && !span.attributes[HTTP_METHOD].nil?
-      end
-
-      # Calculate if this span instance has_error
-      # return [Integer]
-      def error?(span)
-        span.status.code == ::OpenTelemetry::Trace::Status::ERROR ? 1 : 0
-      end
-
-      # Calculate HTTP status_code from span or default to UNAVAILABLE
-      # Something went wrong in OTel or instrumented service crashed early
-      # if no status_code in attributes of HTTP span
-      def get_http_status_code(span)
-        span.attributes[HTTP_STATUS_CODE] || LIBOBOE_HTTP_SPAN_STATUS_UNAVAILABLE
-      end
-
-      # check if it's entry span based on no parent or parent is remote
-      def non_entry_span(span: nil, parent_context: nil)
-        if parent_context
-          parent_span = ::OpenTelemetry::Trace.current_span(parent_context)
-          parent_span && parent_span.context != ::OpenTelemetry::Trace::SpanContext::INVALID && parent_span.context.remote? == false
-        elsif span
-          span.attributes['sw.is_entry_span'] != true
-        end
-      end
-
-      # Get trans_name and url_tran of this span instance.
-      # Predecessor order: custom SDK > env var SW_APM_TRANSACTION_NAME > automatic naming
-      def calculate_transaction_names(span)
-        trace_span_id = "#{span.context.hex_trace_id}-#{span.context.hex_span_id}"
-        trans_name = @txn_manager.get(trace_span_id)
-        if trans_name
-          SolarWindsAPM.logger.debug do
-            "[#{self.class}/#{__method__}] found trans name from txn_manager: #{trans_name} by #{trace_span_id}"
-          end
-          @txn_manager.del(trace_span_id)
-        elsif ENV.key?('SW_APM_TRANSACTION_NAME') && ENV['SW_APM_TRANSACTION_NAME'] != ''
-          trans_name = ENV.fetch('SW_APM_TRANSACTION_NAME', nil)
-        else
-          trans_name = span.attributes[HTTP_ROUTE] || nil
-          trans_name = span.name if span.name && (trans_name.nil? || trans_name.empty?)
-        end
-        trans_name
-      end
-
-      # Calculate span time in microseconds (us) using start and end time
-      # in nanoseconds (ns). OTel span start/end_time are optional.
-      def calculate_span_time(start_time: nil, end_time: nil)
-        return 0 if start_time.nil? || end_time.nil?
-
-        ((end_time.to_i - start_time.to_i) / 1e3).round
-      end
-    end
-  end
-end

data/lib/solarwinds_apm/opentelemetry/solarwinds_sampler.rb

@@ -1,333 +0,0 @@
-# frozen_string_literal: true
-
-# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at:http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
-
-module SolarWindsAPM
-  module OpenTelemetry
-    # SolarWindsSampler
-    class SolarWindsSampler
-      INTERNAL_BUCKET_CAPACITY   = 'BucketCapacity'
-      INTERNAL_BUCKET_RATE       = 'BucketRate'
-      INTERNAL_SAMPLE_RATE       = 'SampleRate'
-      INTERNAL_SAMPLE_SOURCE     = 'SampleSource'
-      INTERNAL_SW_KEYS           = 'SWKeys'
-      LIBOBOE_CONTINUED          = -1
-      SW_TRACESTATE_CAPTURE_KEY  = 'sw.w3c.tracestate'
-      SW_TRACESTATE_ROOT_KEY     = 'sw.tracestate_parent_id'
-      UNSET                      = -1
-      SWO_TRACING_ENABLED        = 1
-      SWO_TRACING_DISABLED       = 0
-      SWO_TRACING_UNSET          = -1
-      XTRACEOPTIONS_RESP_AUTH    = 'auth'
-      XTRACEOPTIONS_RESP_IGNORED = 'ignored'
-      XTRACEOPTIONS_RESP_TRIGGER_IGNORED       = 'ignored'
-      XTRACEOPTIONS_RESP_TRIGGER_NOT_REQUESTED = 'not-requested'
-      XTRACEOPTIONS_RESP_TRIGGER_TRACE         = 'trigger-trace'
-
-      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? start 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
-
-        SolarWindsAPM::Reporter.send(:report_init) # This only happens if after_fork enabled
-
-        parent_span_context = ::OpenTelemetry::Trace.current_span(parent_context).context
-        xtraceoptions       = ::SolarWindsAPM::XTraceOptions.new(parent_context)
-        SolarWindsAPM.logger.debug do
-          "[#{self.class}/#{__method__}] parent_span_context: #{parent_span_context.inspect}\n xtraceoptions: #{xtraceoptions.inspect}"
-        end
-
-        liboboe_decision    = calculate_liboboe_decision(parent_span_context, xtraceoptions, name, kind, attributes)
-        otel_decision       = otel_decision_from_liboboe(liboboe_decision)
-        new_trace_state     = calculate_trace_state(liboboe_decision, parent_span_context, xtraceoptions)
-        new_attributes      = if otel_sampled?(otel_decision)
-                                calculate_attributes(attributes, liboboe_decision,
-                                                     new_trace_state, parent_span_context, xtraceoptions)
-                              end
-        sampling_result     = ::OpenTelemetry::SDK::Trace::Samplers::Result.new(decision: otel_decision,
-                                                                                attributes: new_attributes,
-                                                                                tracestate: new_trace_state)
-
-        SolarWindsAPM.logger.debug do
-          "[#{self.class}/#{__method__}] should_sample? end with sampling_result: #{sampling_result.inspect} from otel_decision: #{otel_decision.inspect} and new_attributes: #{new_attributes.inspect}"
-        end
-        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
-
-      attr_reader :decision
-
-      private
-
-      ##
-      # 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 = 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)
-        SolarWindsAPM.logger.debug do
-          "[#{self.class}/#{__method__}] transaction cache: #{transaction_naming_key}; tracing_mode: #{tracing_mode}."
-        end
-
-        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)
-        end
-
-        sw_member_value    = parent_span_context.tracestate[SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY]
-        trigger_trace_mode = SolarWindsAPM::OboeTracingMode.get_oboe_trigger_trace_mode(@config['trigger_trace'])
-        sample_rate        = UNSET
-        options            = xtraceoptions&.options
-        trigger_trace      = xtraceoptions&.intify_trigger_trace || 0
-        signature          = xtraceoptions&.signature
-        timestamp          = xtraceoptions&.timestamp
-
-        SolarWindsAPM.logger.debug do
-          "[#{self.class}/#{__method__}] get liboboe 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]
-
-        if SolarWindsAPM::OboeInitOptions.instance.lambda_env
-          SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] get decision from oboe_api" }
-          # trigger trace disabled at this point (https://swicloud.atlassian.net/wiki/spaces/NIT/pages/3753116438/AWS+Lambda+Instrumentation+POC#Concerns)
-          do_metrics, do_sample, rate, source, bucket_rate,
-            bucket_cap, decision_type, auth, status_msg, auth_msg,
-              status = SolarWindsAPM.oboe_api.getTracingDecision(*args)
-        else
-          do_metrics, do_sample, rate, source, bucket_rate,
-            bucket_cap, decision_type, auth, status_msg, auth_msg,
-              status = SolarWindsAPM::Context.getDecisions(*args)
-        end
-
-        {
-          'do_metrics' => do_metrics.positive?,
-          'do_sample' => do_sample.positive?,
-          'rate' => rate,
-          'source' => source,
-          'bucket_rate' => bucket_rate,
-          'bucket_cap' => bucket_cap,
-          'decision_type' => decision_type,
-          'auth' => auth,
-          'status_msg' => status_msg,
-          'auth_msg' => auth_msg,
-          'status' => status
-        }
-      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: #{decision} created from liboboe_decision: #{liboboe_decision}" }
-        decision
-      end
-
-      ##
-      # 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? || parent_span_context.tracestate.nil?
-          trace_state = create_new_trace_state(parent_span_context, liboboe_decision)
-        else
-          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(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
-
-      ##
-      #
-      def create_xtraceoptions_response_value(liboboe_decision, parent_span_context, xtraceoptions)
-        response = []
-        w3c_sanitized = SolarWindsAPM::Constants::INTL_SWO_EQUALS_W3C_SANITIZED
-        w3c_sanitized_comma = SolarWindsAPM::Constants::INTL_SWO_COMMA_W3C_SANITIZED
-        if xtraceoptions.signature && liboboe_decision['auth_msg']
-          response << [XTRACEOPTIONS_RESP_AUTH,
-                       liboboe_decision['auth_msg']].join(w3c_sanitized)
-        end
-
-        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']).zero? ? XTRACEOPTIONS_RESP_TRIGGER_IGNORED : liboboe_decision['status_msg']
-            SolarWindsAPM.logger.debug do
-              "[#{self.class}/#{__method__}] tracestring: #{tracestring}; trigger_msg: #{trigger_msg}"
-            end
-          else
-            trigger_msg = XTRACEOPTIONS_RESP_TRIGGER_NOT_REQUESTED
-          end
-
-          response << [XTRACEOPTIONS_RESP_TRIGGER_TRACE, trigger_msg].join(w3c_sanitized) # e.g. response << trigger-trace####ok
-        end
-
-        # appending ignored value from xtraceoptions to response. e.g. response << ignored####invalidkeys,invalidkeys,invalidkeys
-        unless xtraceoptions.ignored.empty?
-          response << [XTRACEOPTIONS_RESP_IGNORED,
-                       xtraceoptions.ignored.join(w3c_sanitized_comma)].join(w3c_sanitized)
-        end
-        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 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, 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
-
-        # 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] = 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)
-        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
-
-        # 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 do
-            "[#{self.class}/#{__method__}] No valid traceparent or no tracestate - returning attributes: #{new_attributes}"
-          end
-          return new_attributes.freeze || nil
-        end
-
-        new_attributes = add_tracestate_capture_to_new_attributes(new_attributes, liboboe_decision, trace_state,
-                                                                  parent_span_context)
-        new_attributes.freeze
-      end
-
-      ##
-      #
-      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 do
-          "[#{self.class}/#{__method__}] tracestate_capture #{tracestate_capture.inspect}; new_attributes #{new_attributes.inspect}"
-        end
-
-        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 do
-          "[#{self.class}/#{__method__}] trace_state_no_response #{trace_state_no_response.inspect}"
-        end
-
-        trace_state_no_response = parent_span_context.tracestate.delete(XTraceOptions.sw_xtraceoptions_response_key)
-        no_sw_count             = trace_state_no_response.to_h.count { |k, _v| k != 'sw' }
-
-        if no_sw_count.positive?
-          new_attributes[SW_TRACESTATE_CAPTURE_KEY] =
-            Utils.trace_state_header(trace_state_no_response)
-        end
-        SolarWindsAPM.logger.debug do
-          "[#{self.class}/#{__method__}] new_attributes after add_tracestate_capture_to_new_attributes: #{new_attributes.inspect}"
-        end
-
-        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
-end

data/lib/solarwinds_apm/otel_config.rb

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-
-# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at:http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
-
-module SolarWindsAPM
-  # 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(reason: nil)
-      return unless @@agent_enabled # only show the msg once
-
-      @@agent_enabled = false
-      SolarWindsAPM.logger.warn { "[#{name}/#{__method__}] SolarWindsAPM disabled. No Trace exported. Reason: #{reason}" }
-    end
-
-    def self.resolve_sampler
-      sampler_config = { 'trigger_trace' => SolarWindsAPM::Config[:trigger_tracing_mode] }
-      @@config[:sampler] =
-        ::OpenTelemetry::SDK::Trace::Samplers.parent_based(
-          root: SolarWindsAPM::OpenTelemetry::SolarWindsSampler.new(sampler_config),
-          remote_parent_sampled: SolarWindsAPM::OpenTelemetry::SolarWindsSampler.new(sampler_config),
-          remote_parent_not_sampled: SolarWindsAPM::OpenTelemetry::SolarWindsSampler.new(sampler_config)
-        )
-    end
-
-    #
-    # append/add solarwinds_response_propagator into rack instrumentation
-    #
-    def self.resolve_response_propagator
-      response_propagator  = SolarWindsAPM::OpenTelemetry::SolarWindsResponsePropagator::TextMapPropagator.new
-      rack_setting         = @@config_map['OpenTelemetry::Instrumentation::Rack']
-
-      if rack_setting
-        if rack_setting[:response_propagators].instance_of?(Array)
-          rack_setting[:response_propagators].append(response_propagator)
-        elsif rack_setting[:response_propagators].nil?
-          rack_setting[:response_propagators] = [response_propagator]
-        else
-          SolarWindsAPM.logger.warn do
-            "[#{name}/#{__method__}] Rack response propagator resolve failed. Provided type #{rack_setting[:response_propagators].class}, please provide Array e.g. [#{rack_setting[:response_propagators]}]"
-          end
-        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 |k, v|
-        SolarWindsAPM.logger.debug { "[#{name}/#{__method__}] Config Key/Value: #{k}, #{v.class}" }
-      end
-      @@config_map.each do |k, v|
-        SolarWindsAPM.logger.debug { "[#{name}/#{__method__}] Config Key/Value: #{k}, #{v}" }
-      end
-      nil
-    end
-
-    def self.resolve_solarwinds_processor
-      txn_manager = SolarWindsAPM::TxnNameManager.new
-      exporter = SolarWindsAPM::OpenTelemetry::SolarWindsExporter.new(txn_manager: txn_manager)
-      @@config[:metrics_processor] = SolarWindsAPM::OpenTelemetry::SolarWindsProcessor.new(txn_manager)
-      @@config[:span_processor] = ::OpenTelemetry::SDK::Trace::Export::BatchSpanProcessor.new(exporter)
-    end
-
-    def self.resolve_solarwinds_propagator
-      @@config[:propagators] = SolarWindsAPM::OpenTelemetry::SolarWindsPropagator::TextMapPropagator.new
-    end
-
-    def self.validate_propagator(propagators)
-      if propagators.nil?
-        disable_agent(reason: 'propagators are invaliad.')
-        return
-      end
-
-      SolarWindsAPM.logger.debug { "[#{name}/#{__method__}] propagators: #{propagators.map(&:class)}" }
-      disable_agent(reason: 'Missing tracecontext propagator.') unless ([::OpenTelemetry::Trace::Propagation::TraceContext::TextMapPropagator, ::OpenTelemetry::Baggage::Propagation::TextMapPropagator] - propagators.map(&:class)).empty?
-    end
-
-    def self.initialize
-      unless defined?(::OpenTelemetry::SDK::Configurator)
-        disable_agent(reason: 'missing OpenTelemetry::SDK::Configurator; opentelemetry seems not loaded.')
-        return
-      end
-
-      resolve_sampler
-      resolve_solarwinds_propagator
-      resolve_solarwinds_processor
-      resolve_response_propagator
-
-      print_config if SolarWindsAPM.logger.level.zero?
-
-      # resolve OTEL environmental variables
-      ENV['OTEL_TRACES_EXPORTER'] = 'none' if ENV['OTEL_TRACES_EXPORTER'].to_s.empty?
-      if ENV['OTEL_LOG_LEVEL'].to_s.empty?
-        log_level = (ENV['SW_APM_DEBUG_LEVEL'] || SolarWindsAPM::Config[:debug_level] || 3).to_i
-        ENV['OTEL_LOG_LEVEL'] = SolarWindsAPM::Config::SW_LOG_LEVEL_MAPPING.dig(log_level, :otel)
-      end
-
-      # for dbo, traceparent injection as comments
-      require_relative 'patch/tag_sql_patch' if SolarWindsAPM::Config[:tag_sql]
-
-      ::OpenTelemetry::SDK.configure { |c| c.use_all(@@config_map) }
-
-      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[:metrics_processor])
-      ::OpenTelemetry.tracer_provider.add_span_processor(@@config[:span_processor])
-
-      # configure sampler afterwards
-      ::OpenTelemetry.tracer_provider.sampler = @@config[:sampler]
-
-      if ENV['SW_APM_AUTO_CONFIGURE'] == 'false'
-        SolarWindsAPM.logger.info '==================================================================='
-        SolarWindsAPM.logger.info "\e[1mSolarWindsAPM manual initialization was successful.\e[0m"
-        SolarWindsAPM.logger.info '==================================================================='
-      end
-
-      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 do
-          "[#{name}/#{__method__}] Block not given while doing in-code configuration. Agent disabled."
-        end
-        return
-      end
-
-      yield @@config_map
-
-      if @@config_map.empty?
-        SolarWindsAPM.logger.warn do
-          "[#{name}/#{__method__}] No configuration given for in-code configuration. Agent disabled."
-        end
-        return
-      end
-
-      initialize
-    end
-  end
-end