solarwinds_apm 6.1.2 → 7.0.0.prev1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73f2befcea2c555995f79719d36c68d2448ae31f56656741d5c6e8d49e61963b
-  data.tar.gz: 4ba3986285dcda8adc5629c2e08b5221638928d06733dd6fc0c009379b97ab4b
+  metadata.gz: 2d66514bebfccf2f3c5a2b2e6924fe7fc7abe6a33fa90ce2dcc94de968e64018
+  data.tar.gz: 55cd6df597c8db22130b6322ede1deae4911c1409674734cb11ccf9223734dcb
 SHA512:
-  metadata.gz: 777aebc61cfb1f6776f0640f9b0cbd6005c5c375989a046809ce4f97551a8f2925154496eeef798726ac2242641646bb590c48d23caf71165473b0ac0cfa6b52
-  data.tar.gz: c244cb0d3c1252cbcb85f3381cc82195ca8d59bf0ea4991f2c41f89a49d29a92efcf089ee35ae6274614493bd7e89d7ecb5851ec876a572d24fc5015ec7d5625
+  metadata.gz: fa5dd5bb46399211d816833f257b69fec64a325cb6ee3c256d612d64be0e4cb50e5b1e195025afad69dee4d5c79726d9e5b6ff8f5a25d952724b01521e8d9331
+  data.tar.gz: 6b9e3f5bc1e8e35b419d9a2c04c43bca23268ea9fed3832368d5f0c708925abd1e46d9f2e215833fae5e6154fa77c7ec696e3819a0ff37188c1c407aa4965522

data/README.md

@@ -89,6 +89,7 @@ add_tracer :method_name, 'custom_span_name', { attributes: { 'any' => 'attribute
 For example, if you want to instrument class or instance method `create_session` inside an application controller:
 
 To instrument instance method
+
 ```ruby
 class SessionsController < ApplicationController
   include SolarWindsAPM::API::Tracer
@@ -107,6 +108,7 @@ end
 ```
 
 To instrument class method
+
 ```ruby
 class SessionsController < ApplicationController
   def create
@@ -142,10 +144,10 @@ trace.trace_flags    # 01
 
 On startup, this library initializes and maintains a connection to a SolarWinds Observability collector, and receives settings used for making tracing decisions. This process can take up to a few seconds depending on the connection. If the application receives requests before initialization has completed, these requests will not be traced. While this is not critical for long-running server processes, it might be a problem for short-running apps such as cron jobs or CLI apps.
 
-A call to the `solarwinds_ready` method allows the application to block until initialization has completed and the library is ready for tracing. The method accepts an optional timeout parameter in milliseconds.
+A call to the `solarwinds_ready?` method allows the application to block until initialization has completed and the library is ready for tracing. The method accepts an optional timeout parameter in milliseconds.
 
 ```ruby
-SolarWindsAPM::API.solarwinds_ready(wait_milliseconds=3000)
+SolarWindsAPM::API.solarwinds_ready?(wait_milliseconds=3000)
 ```
 
 #### Set a Custom Transaction Name

data/lib/solarwinds_apm/api/current_trace_info.rb

@@ -111,12 +111,16 @@ module SolarWindsAPM
         private
 
         def current_span
-          span     = ::OpenTelemetry::Trace.current_span if defined?(::OpenTelemetry::Trace)
-          trace_id = span.context.hex_trace_id
-          span_id  = span.context.hex_span_id
-          trace_flags = span.context.trace_flags.sampled? ? '01' : '00'
-          tracestring = "00-#{trace_id}-#{span_id}-#{trace_flags}"
-          [trace_id, span_id, trace_flags, tracestring]
+          if defined?(::OpenTelemetry::Trace)
+            span     = ::OpenTelemetry::Trace.current_span
+            trace_id = span.context.hex_trace_id
+            span_id  = span.context.hex_span_id
+            trace_flags = span.context.trace_flags.sampled? ? '01' : '00'
+            tracestring = "00-#{trace_id}-#{span_id}-#{trace_flags}"
+            [trace_id, span_id, trace_flags, tracestring]
+          else
+            %w[00000000000000000000000000000000 00000000 00 00-00000000000000000000000000000000-00000000-00]
+          end
         end
 
         # if true the trace info should be added to the log message

data/lib/solarwinds_apm/api/custom_metrics.rb

@@ -32,12 +32,9 @@ module SolarWindsAPM
       # === Returns:
       # * Boolean
       #
-      def increment_metric(name, count = 1, with_hostname = false, tags_kvs = {}) # rubocop:disable Style/OptionalBooleanParameter
-        return true unless SolarWindsAPM.loaded
-
-        with_hostname = with_hostname ? 1 : 0
-        tags, tags_count = make_tags(tags_kvs)
-        SolarWindsAPM::CustomMetrics.increment(name.to_s, count, with_hostname, nil, tags, tags_count).zero?
+      def increment_metric(_name, _count = 1, _with_hostname = false, _tags_kvs = {}) # rubocop:disable Style/OptionalBooleanParameter
+        SolarWindsAPM.logger.warn { 'increment_metric have been deprecated. Please use opentelemetry metrics-sdk to log metrics data.' }
+        false
       end
 
       # Send values with counts
@@ -66,29 +63,15 @@ module SolarWindsAPM
       # === Returns:
       # * Boolean
       #
-      def summary_metric(name, value, count = 1, with_hostname = false, tags_kvs = {}) # rubocop:disable Style/OptionalBooleanParameter
-        return true unless SolarWindsAPM.loaded
-
-        with_hostname = with_hostname ? 1 : 0
-        tags, tags_count = make_tags(tags_kvs)
-        SolarWindsAPM::CustomMetrics.summary(name.to_s, value, count, with_hostname, nil, tags, tags_count).zero?
+      def summary_metric(_name, _value, _count = 1, _with_hostname = false, _tags_kvs = {}) # rubocop:disable Style/OptionalBooleanParameter
+        SolarWindsAPM.logger.warn { 'summary_metric have been deprecated. Please use opentelemetry metrics-sdk to log metrics data.' }
+        false
       end
 
       private
 
-      def make_tags(tags_kvs)
-        unless tags_kvs.is_a?(Hash)
-          SolarWindsAPM.logger.warn("[solarwinds_apm/metrics] CustomMetrics received tags_kvs that are not a Hash (found #{tags_kvs.class}), setting tags_kvs = {}")
-          tags_kvs = {}
-        end
-        count = tags_kvs.size
-        tags = SolarWindsAPM::MetricTags.new(count)
-
-        tags_kvs.each_with_index do |(k, v), i|
-          tags.add(i, k.to_s, v.to_s)
-        end
-
-        [tags, count]
+      def make_tags(_tags_kvs)
+        nil
       end
     end
   end

data/lib/solarwinds_apm/api/tracing.rb

@@ -12,22 +12,12 @@ module SolarWindsAPM
       # Wait for SolarWinds to be ready to send traces.
       #
       # This may be useful in short lived background processes when it is important to capture
-      # information during the whole time the process is running. It returns boolean if <tt>integer_response</tt> is false,
-      # and it will return integer if setting <tt>integer_response</tt> as true.
+      # information during the whole time the process is running.
       # Usually SolarWinds doesn't block an application while it is starting up.
       #
-      # For status code reference:
-      #   0: unknown error
-      #   1: is ready
-      #   2: not ready yet, try later
-      #   3: limit exceeded
-      #   4: invalid API key
-      #   5: connection error
-      #
       # === Argument:
       #
       # * +wait_milliseconds+ - (int, default 3000) the maximum time to wait in milliseconds
-      # * +integer_response+  - (boolean, default false) determine whether return status code of reporter or not
       #
       # === Example:
       #
@@ -35,24 +25,19 @@ module SolarWindsAPM
       #     Logger.info "SolarWindsAPM not ready after 10 seconds, no metrics will be sent"
       #   end
       #
-      #   # with status code print out
-      #   status = SolarWindsAPM::API.solarwinds_ready?(10_000, integer_response: true)
-      #   unless status == 1
-      #     Logger.info "SolarWindsAPM not ready after 10 seconds, no metrics will be sent. Error code "#{status}"
-      #   end
-      #
       # === Returns:
-      # * Boolean (if integer_response: false)
-      # * Integer (if integer_response: true)
-      #
-      def solarwinds_ready?(wait_milliseconds = 3000, integer_response: false)
-        return false unless SolarWindsAPM.loaded
-
-        is_ready = SolarWindsAPM::Context.isReady(wait_milliseconds)
-
-        return is_ready if integer_response
+      # * Boolean
+      #
+      def solarwinds_ready?(wait_milliseconds = 3000, integer_response: nil)
+        unless integer_response.nil?
+          SolarWindsAPM.logger.warn do
+            'Deprecation: solarwinds_ready? no longer accepts integer_response, this parameter will be removed in the next release.'
+          end
+        end
 
-        is_ready == 1
+        root_sampler = ::OpenTelemetry.tracer_provider.sampler.instance_variable_get(:@root)
+        is_ready = root_sampler.wait_until_ready(wait_milliseconds / 1000)
+        !!is_ready
       end
     end
   end

data/lib/solarwinds_apm/api/transaction_name.rb

@@ -39,23 +39,19 @@ module SolarWindsAPM
       #
       def set_transaction_name(custom_name = nil)
         status = true
-        if ENV.fetch('SW_APM_ENABLED', 'true') == 'false' ||
-           SolarWindsAPM::Context.toString == '99-00000000000000000000000000000000-0000000000000000-00'
-          # library disabled or noop, just log and skip work.
-          # TODO: can we have a single indicator that the API is in noop mode?
+        if ENV.fetch('SW_APM_ENABLED', 'true') == 'false'
           SolarWindsAPM.logger.debug { "[#{name}/#{__method__}] SolarWindsAPM is in disabled or noop mode." }
-        elsif custom_name.nil? || custom_name.empty?
+        elsif SolarWindsAPM::OTelNativeConfig[:metrics_processor].nil?
           SolarWindsAPM.logger.warn do
-            "[#{name}/#{__method__}] Set transaction name failed: custom_name is either nil or empty string."
+            "[#{name}/#{__method__}] Set transaction name failed: Solarwinds processor is missing. Noop mode."
           end
-          status = false
-        elsif SolarWindsAPM::OTelConfig[:metrics_processor].nil?
+        elsif custom_name.nil? || custom_name.empty?
           SolarWindsAPM.logger.warn do
-            "[#{name}/#{__method__}] Set transaction name failed: Solarwinds processor is missing."
+            "[#{name}/#{__method__}] Set transaction name failed: custom_name is either nil or empty string."
           end
           status = false
         else
-          solarwinds_processor = SolarWindsAPM::OTelConfig[:metrics_processor]
+          solarwinds_processor = SolarWindsAPM::OTelNativeConfig[:metrics_processor]
           current_span = ::OpenTelemetry::Trace.current_span
 
           if current_span.context.valid?

data/lib/solarwinds_apm/config.rb

@@ -212,7 +212,7 @@ module SolarWindsAPM
 
         # Assure value is an integer
         @@config[key.to_sym] = new_value.to_i
-        SolarWindsAPM.sample_rate(new_value) if SolarWindsAPM.loaded
+        SolarWindsAPM.sample_rate(new_value)
 
       when :transaction_settings
         compile_settings(value)

data/lib/solarwinds_apm/constants.rb

@@ -32,5 +32,6 @@ module SolarWindsAPM
     INTL_SWO_OTEL_STATUS             = 'otel.status_code'
     INTL_SWO_OTEL_STATUS_DESCRIPTION = 'otel.status_description'
     INTERNAL_TRIGGERED_TRACE         = 'TriggeredTrace'
+    MAX_TXN_NAME_LENGTH              = 256
   end
 end

data/lib/solarwinds_apm/noop/api.rb

@@ -19,8 +19,9 @@ module NoopAPI
   # Tracing
   module Tracing
     # (wait_milliseconds=3000, integer_response: false)
-    def solarwinds_ready?(*_args, **options)
-      options && options[:integer_response] ? 0 : false
+    def solarwinds_ready?(_wait_milliseconds = 3000, integer_response: false)
+      _noop = integer_response
+      false
     end
   end
 
@@ -55,10 +56,12 @@ module NoopAPI
   # CustomMetrics
   module CustomMetrics
     def increment_metric(*)
+      SolarWindsAPM.logger.warn { 'increment_metric have been deprecated. Please use opentelemetry metrics-sdk to log metrics data.' }
       false
     end
 
     def summary_metric(*)
+      SolarWindsAPM.logger.warn { 'summary_metric have been deprecated. Please use opentelemetry metrics-sdk to log metrics data.' }
       false
     end
   end

data/lib/solarwinds_apm/noop.rb

@@ -6,28 +6,4 @@
 #
 # 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.
 
-require_relative 'noop/context'
-require_relative 'noop/metadata'
-require_relative 'noop/span'
 require_relative 'noop/api'
-
-module SolarWindsAPM
-  include Oboe_metal
-  # Reporter noop
-  class Reporter
-    ##
-    # noop version of :send_report
-    #
-    def self.send_report(event, with_system_timestamp: false); end
-
-    ##
-    # noop version of :send_status
-    #
-    def self.send_status(event, context = nil, with_system_timestamp: false); end
-
-    ##
-    # noop version of :start
-    #
-    def self.start; end
-  end
-end

data/lib/solarwinds_apm/opentelemetry/otlp_processor.rb

@@ -8,41 +8,60 @@
 
 module SolarWindsAPM
   module OpenTelemetry
-    # reference: OpenTelemetry::SDK::Trace::SpanProcessor; inheritance: SolarWindsProcessor
-    class OTLPProcessor < SolarWindsProcessor
-      attr_accessor :description
-
-      def initialize
-        super(nil)
-        @meters  = init_meters
-        @metrics = init_metrics
+    # reference: OpenTelemetry::SDK::Trace::SpanProcessor
+    class OTLPProcessor
+      attr_reader :txn_manager
+
+      SW_TRANSACTION_NAME = 'sw.transaction'
+      SW_IS_ENTRY_SPAN    = 'sw.is_entry_span'
+      SW_IS_ERROR         = 'sw.is_error'
+
+      HTTP_METHOD         = 'http.method'
+      HTTP_ROUTE          = 'http.route'
+      HTTP_STATUS_CODE    = 'http.status_code'
+      HTTP_URL            = 'http.url'
+
+      INVALID_HTTP_STATUS_CODE = 0
+
+      def initialize(txn_manager)
+        @txn_manager = txn_manager
+        @meters      = { 'sw.apm.request.metrics' => ::OpenTelemetry.meter_provider.meter('sw.apm.request.metrics') }
+        @metrics     = { response_time: @meters['sw.apm.request.metrics'].create_histogram('trace.service.response_time', unit: 'ms', description: 'Duration of each entry span for the service, typically meaning the time taken to process an inbound request.') }
+        @transaction_name = nil
       end
 
-      # @param [Span] span the {Span} that just started.
-      # @param [Context] parent_context the
-      #  started span.
+      # @param [Span] span the (mutable) {Span} that just started.
+      # @param [Context] parent_context of the started span.
       def on_start(span, parent_context)
         SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] processor on_start span: #{span.to_span_data.inspect}" }
 
         return if non_entry_span(parent_context: parent_context)
 
-        span.add_attributes(span_attributes(span))
-        span.add_attributes({ 'sw.is_entry_span' => true })
+        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
 
-      # @param [Span] span the {Span} that just ended.
+      def on_finishing(span)
+        @transaction_name = calculate_transaction_names(span)
+        span.set_attribute(SW_TRANSACTION_NAME, @transaction_name)
+        @txn_manager.delete_root_context_h(span.context.hex_trace_id)
+      end
+
+      # @param [Span] span the (immutable) {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 span is non-entry span
         return if non_entry_span(span: span)
 
         record_request_metrics(span)
-        record_sampling_metrics
 
-        ::OpenTelemetry.meter_provider.metric_readers.each(&:pull)
+        # pull should work on any instrument from oboe_sampler
+        ::OpenTelemetry.meter_provider.metric_readers.each do |reader|
+          reader.pull if reader.respond_to? :pull
+        end
+
         SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] processor on_finish succeed" }
       rescue StandardError => e
         SolarWindsAPM.logger.info { "[#{self.class}/#{__method__}] error processing span on_finish: #{e.message}" }
@@ -50,24 +69,10 @@ module SolarWindsAPM
 
       private
 
-      # Create two meters for sampling and request count
-      def init_meters
-        {
-          'sw.apm.sampling.metrics' => ::OpenTelemetry.meter_provider.meter('sw.apm.sampling.metrics'),
-          'sw.apm.request.metrics' => ::OpenTelemetry.meter_provider.meter('sw.apm.request.metrics')
-        }
-      end
-
-      def span_attributes(span)
-        span_attrs = { 'sw.transaction' => calculate_lambda_transaction_name(span) }
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] span_attrs: #{span_attrs.inspect}" }
-        span_attrs
-      end
-
       def meter_attributes(span)
         meter_attrs = {
-          'sw.is_error' => error?(span) == 1,
-          'sw.transaction' => calculate_lambda_transaction_name(span)
+          SW_IS_ERROR => error?(span) == 1,
+          SW_TRANSACTION_NAME => @transaction_name
         }
 
         if span_http?(span)
@@ -76,26 +81,33 @@ module SolarWindsAPM
           meter_attrs['http.method'] = span.attributes[HTTP_METHOD] if span.attributes[HTTP_METHOD]
         end
         SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] meter_attrs: #{meter_attrs.inspect}" }
+        meter_attrs.compact!
         meter_attrs
       end
 
-      def calculate_lambda_transaction_name(span)
-        (ENV['SW_APM_TRANSACTION_NAME'] || ENV['AWS_LAMBDA_FUNCTION_NAME'] || span.name || 'unknown').slice(0, 255)
+      def calculate_lambda_transaction_name(span_name)
+        (ENV['SW_APM_TRANSACTION_NAME'] || ENV['AWS_LAMBDA_FUNCTION_NAME'] || span_name || 'unknown').slice(0, SolarWindsAPM::Constants::MAX_TXN_NAME_LENGTH)
       end
 
-      def init_metrics
-        request_meter = @meters['sw.apm.request.metrics']
-        sampling_meter = @meters['sw.apm.sampling.metrics']
-
-        metrics = {}
-        metrics[:response_time] = request_meter.create_histogram('trace.service.response_time', unit: 'ms', description: 'measures the duration of an inbound HTTP request')
-        metrics[:tracecount]    = sampling_meter.create_counter('trace.service.tracecount')
-        metrics[:samplecount]   = sampling_meter.create_counter('trace.service.samplecount')
-        metrics[:request_count] = sampling_meter.create_counter('trace.service.request_count')
-        metrics[:toex_count]    = sampling_meter.create_counter('trace.service.tokenbucket_exhaustion_count')
-        metrics[:through_count] = sampling_meter.create_counter('trace.service.through_trace_count')
-        metrics[:tt_count]      = sampling_meter.create_counter('trace.service.triggered_trace_count')
-        metrics
+      # 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)
+        return calculate_lambda_transaction_name(span.name) if SolarWindsAPM::Utils.determine_lambda
+
+        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['SW_APM_TRANSACTION_NAME'].to_s.empty?
+          trans_name = ENV.fetch('SW_APM_TRANSACTION_NAME', nil)
+        else
+          trans_name = span.attributes[HTTP_ROUTE] || nil
+          trans_name = span.name if trans_name.to_s.empty? && span.name
+        end
+        trans_name.to_s.slice(0, SolarWindsAPM::Constants::MAX_TXN_NAME_LENGTH)
       end
 
       def record_request_metrics(span)
@@ -106,31 +118,40 @@ module SolarWindsAPM
         @metrics[:response_time].record(span_time, attributes: meter_attrs)
       end
 
-      # oboe_api will return 0 in case of failed operation, and report 0 value
-      def record_sampling_metrics
-        _, trace_count = SolarWindsAPM.oboe_api.consumeTraceCount
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] trace_count: #{trace_count}" }
-        @metrics[:tracecount].add(trace_count)
+      # 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?
 
-        _, sample_count = SolarWindsAPM.oboe_api.consumeSampleCount
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] sample_count: #{sample_count}" }
-        @metrics[:samplecount].add(sample_count)
+        ((end_time.to_i - start_time.to_i) / 1e3).round
+      end
 
-        _, request_count = SolarWindsAPM.oboe_api.consumeRequestCount
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] request_count: #{request_count}" }
-        @metrics[:request_count].add(request_count)
+      # Calculate if this span instance has_error
+      # return [Integer]
+      def error?(span)
+        span.status.code == ::OpenTelemetry::Trace::Status::ERROR ? 1 : 0
+      end
 
-        _, token_bucket_exhaustion_count = SolarWindsAPM.oboe_api.consumeTokenBucketExhaustionCount
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] tokenbucket_exhaustion_count: #{token_bucket_exhaustion_count}" }
-        @metrics[:toex_count].add(token_bucket_exhaustion_count)
+      # 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
 
-        _, through_trace_count = SolarWindsAPM.oboe_api.consumeThroughTraceCount
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] through_trace_count: #{through_trace_count}" }
-        @metrics[:through_count].add(through_trace_count)
+      # 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] || INVALID_HTTP_STATUS_CODE
+      end
 
-        _, triggered_trace_count = SolarWindsAPM.oboe_api.consumeTriggeredTraceCount
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] triggered_trace_count: #{triggered_trace_count}" }
-        @metrics[:tt_count].add(triggered_trace_count)
+      # 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
     end
   end

data/lib/solarwinds_apm/opentelemetry/solarwinds_propagator.rb

@@ -51,8 +51,6 @@ 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__}] inject context: #{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?

data/lib/solarwinds_apm/opentelemetry/solarwinds_response_propagator.rb

@@ -16,6 +16,7 @@ module SolarWindsAPM
         XTRACE_HEADER_NAME                        = 'x-trace'
         XTRACEOPTIONS_RESPONSE_HEADER_NAME        = 'x-trace-options-response'
         INTL_SWO_EQUALS                           = '='
+        SW_XTRACEOPTIONS_RESPONSE_KEY             = 'xtrace_options_response'
 
         private_constant \
           :HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS, :XTRACE_HEADER_NAME,
@@ -36,14 +37,13 @@ module SolarWindsAPM
                    setter: ::OpenTelemetry::Context::Propagation.text_map_setter)
           span_context = ::OpenTelemetry::Trace.current_span(context).context
 
-          SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] context current_span: #{context.instance_variable_get(:@entries)&.values&.first.inspect}" }
           SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] span_context: #{span_context.inspect}" }
 
           return unless span_context&.valid?
 
           x_trace                = Utils.traceparent_from_context(span_context)
           exposed_headers        = [XTRACE_HEADER_NAME]
-          xtraceoptions_response = recover_response_from_tracestate(span_context.tracestate)
+          xtraceoptions_response = recover_response_from_tracestate(span_context)
 
           SolarWindsAPM.logger.debug do
             "[#{self.class}/#{__method__}] x-trace: #{x_trace}; exposed headers: #{exposed_headers.inspect}; x-trace-options-response: #{xtraceoptions_response}"
@@ -69,11 +69,12 @@ module SolarWindsAPM
         private
 
         # sw_xtraceoptions_response_key -> xtrace_options_response
-        def recover_response_from_tracestate(tracestate)
-          sanitized = tracestate.value(XTraceOptions.sw_xtraceoptions_response_key)
+        def recover_response_from_tracestate(span_context)
+          sanitized = span_context.tracestate.value(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_EQUALS)
           sanitized = sanitized.gsub(SolarWindsAPM::Constants::INTL_SWO_COMMA_W3C_SANITIZED,
                                      SolarWindsAPM::Constants::INTL_SWO_COMMA)
           SolarWindsAPM.logger.debug do

data/lib/solarwinds_apm/opentelemetry.rb

@@ -6,14 +6,12 @@
 #
 # 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.
 
-require 'opentelemetry/sdk'
-require 'opentelemetry/instrumentation/all'
-
-# TODO: in future, it should add opentelemetry-metrics-sdk and require it here
+require 'opentelemetry-sdk'
+require 'opentelemetry-metrics-sdk'
+require 'opentelemetry-exporter-otlp'
+require 'opentelemetry-exporter-otlp-metrics'
+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'
 require_relative 'opentelemetry/otlp_processor'