solarwinds_apm 6.1.2 → 7.0.0.prev2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 73f2befcea2c555995f79719d36c68d2448ae31f56656741d5c6e8d49e61963b
-  data.tar.gz: 4ba3986285dcda8adc5629c2e08b5221638928d06733dd6fc0c009379b97ab4b
+  metadata.gz: b697fa83936187a865eb976aa169f2ce33749b479a439b36d4d46754f0252baf
+  data.tar.gz: 774462b35e16d0474c88575f751f763d6d3abf5ab463487050287c4097ab66aa
 SHA512:
-  metadata.gz: 777aebc61cfb1f6776f0640f9b0cbd6005c5c375989a046809ce4f97551a8f2925154496eeef798726ac2242641646bb590c48d23caf71165473b0ac0cfa6b52
-  data.tar.gz: c244cb0d3c1252cbcb85f3381cc82195ca8d59bf0ea4991f2c41f89a49d29a92efcf089ee35ae6274614493bd7e89d7ecb5851ec876a572d24fc5015ec7d5625
+  metadata.gz: '00109285994d22a3a8c871dafd6cdfd8dd8ff482366c18dee94936cf3a79bc9c30e1fe2eab867eeb54771b820cac9d71fb22be0669be397eea70bb11efb54799'
+  data.tar.gz: f2b8a360c720b2f2fcf91a1073ad47c6dabe0cf0c63d724ea00dd7cf95145873537ec71dab9ffc52b2f11201dba26b4805c17b45c59caae436214cadf2c03f44

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
@@ -156,7 +158,7 @@ By default, transaction names are constructed based on attributes such as the re
 result = SolarWindsAPM::API.set_transaction_name('my-custom-trace-name')
 ```
 
-#### Send Custom Metrics
+#### Send Custom Metrics (Depreciated)
 
 Service metrics are automatically collected by this library.  In addition, the following methods support sending two types of custom metrics:
 

data/lib/rails/generators/solarwinds_apm/templates/solarwinds_apm_initializer.rb

@@ -16,8 +16,7 @@
 
 if defined?(SolarWindsAPM::Config)
 
-  # :service_key, :hostname_alias, :http_proxy, and :debug_level
-  # are startup settings and can't be changed afterwards.
+  # :service_key and :debug_level are startup settings and can't be changed afterwards.
 
   #
   # Set SW_APM_SERVICE_KEY
@@ -29,34 +28,6 @@ if defined?(SolarWindsAPM::Config)
   #
   # SolarWindsAPM::Config[:service_key] = '0123456789abcde0123456789abcde0123456789abcde0123456789abcde1234:my_service'
 
-  #
-  # Set SW_APM_HOSTNAME_ALIAS
-  # This setting will be overridden if SW_APM_HOSTNAME_ALIAS is set as an environment variable
-  #
-  # SolarWindsAPM::Config[:hostname_alias] = 'alias_name'
-
-  #
-  # Set Proxy for SolarWinds
-  # This setting will be overridden if SW_APM_PROXY is set as an environment variable.
-  #
-  # Please configure http_proxy if a proxy needs to be used to communicate with
-  # the SolarWinds APM collector.
-  # The format should either be http://<proxyHost>:<proxyPort> for a proxy
-  # server that does not require authentication, or
-  # http://<username>:<password>@<proxyHost>:<proxyPort> for a proxy server that
-  # requires basic authentication.
-  #
-  # Note that while HTTP is the only type of connection supported, the traffic
-  # to SolarWinds is still encrypted using SSL/TLS.
-  #
-  # It is recommended to configure the proxy in this file or as SW_APM_PROXY
-  # environment variable. However, the agent's underlying network library will
-  # use a system-wide proxy defined in the environment variables grpc_proxy,
-  # https_proxy or http_proxy if no SolarWindsAPM-specific configuration is set.
-  # Please refer to gRPC environment variables for more information.
-  #
-  # SolarWindsAPM::Config[:http_proxy] = http://<proxyHost>:<proxyPort>
-
   #
   # Set SW_APM_DEBUG_LEVEL
   # This setting will be overridden if SW_APM_DEBUG_LEVEL is set as an environment variable.

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)
@@ -226,6 +226,12 @@ module SolarWindsAPM
       when :tag_sql
         enable_disable_config('SW_APM_TAG_SQL', key, value, false, bool: true)
 
+      when :http_proxy
+        SolarWindsAPM.logger.warn { ':http_proxy is deprecated' }
+
+      when :hostname_alias
+        SolarWindsAPM.logger.warn { ':hostname_alias is deprecated' }
+
       else
         @@config[key.to_sym] = 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,66 +8,100 @@
 
 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     = init_response_time_metrics
+        @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)
+        return if non_entry_span(span: 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}" }
       end
 
-      private
+      # @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
 
-      # 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')
-        }
+      # @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
 
-      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
+      private
+
+      def init_response_time_metrics
+        # add the ExponentialBucketHistogram view
+        if defined? ::OpenTelemetry::Exporter::OTLP::Metrics && Gem::Version.new(::OpenTelemetry::Exporter::OTLP::Metrics::VERSION) >= Gem::Version.new('0.5.0')
+          ::OpenTelemetry.meter_provider.add_view('trace.service.response_time',
+                                                  aggregation: ::OpenTelemetry::SDK::Metrics::Aggregation::ExponentialBucketHistogram.new(max_scale: 20),
+                                                  type: :histogram,
+                                                  unit: 'ms')
+        end
+
+        instrument = @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.')
+        { response_time: instrument }
       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 +110,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 +147,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