solarwinds_apm 6.0.0 → 6.0.1

data/lib/solarwinds_apm/opentelemetry/otlp_processor.rb

@@ -0,0 +1,135 @@
+# 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; inheritance: SolarWindsProcessor
+    class OTLPProcessor < SolarWindsProcessor
+      attr_accessor :description
+
+      def initialize
+        super(nil)
+        @meters  = init_meters
+        @metrics = init_metrics
+      end
+
+      # @param [Span] span the {Span} that just started.
+      # @param [Context] parent_context the
+      #  started span.
+      def on_start(span, parent_context)
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] processor on_start span: #{span.inspect}" }
+
+        return if non_entry_span(parent_context: parent_context)
+
+        span.add_attributes(span_attributes(span))
+        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_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)
+        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
+
+      # 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)
+        }
+
+        http_status_code = get_http_status_code(span)
+        meter_attrs['http.status_code'] = http_status_code if http_status_code != 0
+        meter_attrs['http.method'] = span.attributes[HTTP_METHOD] if span.attributes[HTTP_METHOD]
+
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] meter_attrs: #{meter_attrs.inspect}" }
+        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)
+      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
+      end
+
+      def record_request_metrics(span)
+        meter_attrs = meter_attributes(span)
+        span_time = calculate_span_time(start_time: span.start_timestamp, end_time: span.end_timestamp)
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] entry span, response_time: #{span_time}." }
+        @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)
+
+        _, sample_count = SolarWindsAPM.oboe_api.consumeSampleCount
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] sample_count: #{sample_count}" }
+        @metrics[:samplecount].add(sample_count)
+
+        _, request_count = SolarWindsAPM.oboe_api.consumeRequestCount
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] request_count: #{request_count}" }
+        @metrics[:request_count].add(request_count)
+
+        _, 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)
+
+        _, 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)
+
+        _, 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)
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/opentelemetry/solarwinds_exporter.rb

@@ -1,3 +1,5 @@
+# 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
@@ -12,7 +14,7 @@ module SolarWindsAPM
       FAILURE = ::OpenTelemetry::SDK::Trace::Export::FAILURE
 
       private_constant(:SUCCESS, :FAILURE)
-    
+
       def initialize(txn_manager: nil)
         @shutdown           = false
         @txn_manager        = txn_manager
@@ -22,7 +24,7 @@ module SolarWindsAPM
         @version_cache      = {}
       end
 
-      def export(span_data, _timeout: nil)
+      def export(span_data, timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
         return FAILURE if @shutdown
 
         status = SUCCESS
@@ -45,31 +47,36 @@ module SolarWindsAPM
       private
 
       def log_span_data(span_data)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] span_data: #{span_data.inspect}\n"}
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] span_data: #{span_data.inspect}\n" }
 
         md = build_meta_data(span_data)
         event = nil
-        if span_data.parent_span_id != ::OpenTelemetry::Trace::INVALID_SPAN_ID 
+        if span_data.parent_span_id == ::OpenTelemetry::Trace::INVALID_SPAN_ID
+          event = @context.createEntry(md, (span_data.start_timestamp.to_i / 1000).to_i)
+          add_info_transaction_name(span_data, event)
+          SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] Start a new trace." }
+        else
           parent_md = build_meta_data(span_data, parent: true)
           event = @context.createEntry(md, (span_data.start_timestamp.to_i / 1000).to_i, parent_md)
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Continue trace from parent metadata: #{parent_md.toString}."}
-        else
-          event = @context.createEntry(md, (span_data.start_timestamp.to_i / 1000).to_i) 
-          add_info_transaction_name(span_data, event)
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Start a new trace."}
+          SolarWindsAPM.logger.debug do
+            "[#{self.class}/#{__method__}] Continue trace from parent metadata: #{parent_md.toString}."
+          end
         end
-        
+
         layer_name = "#{span_data.kind}:#{span_data.name}"
         event.addInfo('Layer', layer_name)
         event.addInfo('sw.span_kind', span_data.kind.to_s)
         event.addInfo('Language', 'Ruby')
-        
+
         add_instrumentation_scope(event, span_data)
         add_instrumented_framework(event, span_data)
         add_span_data_attributes(event, span_data.attributes) if span_data.attributes
 
-        event.addInfo(SolarWindsAPM::Constants::INTL_SWO_OTEL_STATUS, span_data.status.ok?? 'OK' : 'ERROR')
-        event.addInfo(SolarWindsAPM::Constants::INTL_SWO_OTEL_STATUS_DESCRIPTION, span_data.status.description) unless span_data.status.description.empty?
+        event.addInfo(SolarWindsAPM::Constants::INTL_SWO_OTEL_STATUS, span_data.status.ok? ? 'OK' : 'ERROR')
+        unless span_data.status.description.empty?
+          event.addInfo(SolarWindsAPM::Constants::INTL_SWO_OTEL_STATUS_DESCRIPTION,
+                        span_data.status.description)
+        end
 
         @reporter.send_report(event, with_system_timestamp: false)
 
@@ -81,10 +88,10 @@ module SolarWindsAPM
         event = @context.createExit((span_data.end_timestamp.to_i / 1000).to_i)
         event.addInfo('Layer', layer_name)
         @reporter.send_report(event, with_system_timestamp: false)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Exit a trace: #{event.metadataString}"}
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] Exit a trace: #{event.metadataString}" }
         SUCCESS
       rescue StandardError => e
-        SolarWindsAPM.logger.info {"[#{self.class}/#{__method__}] exporter error: \n #{e.message} #{e.backtrace}\n"}
+        SolarWindsAPM.logger.info { "[#{self.class}/#{__method__}] exporter error: \n #{e.message} #{e.backtrace}\n" }
         FAILURE
       end
 
@@ -93,23 +100,23 @@ module SolarWindsAPM
       def add_span_data_attributes(event, span_attributes)
         target     = 'http.target'
         attributes = span_attributes.dup
-        attributes[target] = attributes[target].split('?').first if attributes[target] && SolarWindsAPM::Config[:log_args] == false # remove url parameters
+        attributes[target] = attributes[target].split('?').first if attributes[target] && SolarWindsAPM::Config[:log_args] == false
         attributes.each { |k, v| event.addInfo(k, v) }
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] span_data attributes added: #{attributes.inspect}"}
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] span_data attributes added: #{attributes.inspect}" }
       end
 
       ##
       # get instrumentation scope data: scope name and version.
       # the version if the opentelemetry-instrumentation-* gem version
       def add_instrumentation_scope(event, span_data)
-        scope_name = ""
-        scope_version = ""
+        scope_name = ''
+        scope_version = ''
         if span_data.instrumentation_scope
           scope_name = span_data.instrumentation_scope.name if span_data.instrumentation_scope.name
           scope_version = span_data.instrumentation_scope.version if span_data.instrumentation_scope.version
         end
-        event.addInfo(SolarWindsAPM::Constants::INTL_SWO_OTEL_SCOPE_NAME, scope_name) 
-        event.addInfo(SolarWindsAPM::Constants::INTL_SWO_OTEL_SCOPE_VERSION, scope_version)        
+        event.addInfo(SolarWindsAPM::Constants::INTL_SWO_OTEL_SCOPE_NAME, scope_name)
+        event.addInfo(SolarWindsAPM::Constants::INTL_SWO_OTEL_SCOPE_VERSION, scope_version)
       end
 
       ##
@@ -118,38 +125,46 @@ module SolarWindsAPM
       def add_instrumented_framework(event, span_data)
         scope_name = span_data.instrumentation_scope.name
         scope_name = scope_name.downcase if scope_name
-        return unless scope_name&.include? "opentelemetry::instrumentation"
-          
-        framework = scope_name.split("::")[2..]&.join("::")
+        return unless scope_name&.include? 'opentelemetry::instrumentation'
+
+        framework = scope_name.split('::')[2..]&.join('::')
         return if framework.nil? || framework.empty?
-        
+
         framework         = normalize_framework_name(framework)
         framework_version = check_framework_version(framework)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] #{span_data.instrumentation_scope.name} with #{framework} and version #{framework_version}"}
-        event.addInfo("Ruby.#{framework}.Version",framework_version) unless framework_version.nil?
+        SolarWindsAPM.logger.debug do
+          "[#{self.class}/#{__method__}] #{span_data.instrumentation_scope.name} with #{framework} and version #{framework_version}"
+        end
+        event.addInfo("Ruby.#{framework}.Version", framework_version) unless framework_version.nil?
       end
 
       ##
       # helper function that extract gem library version for func add_instrumented_framework
       def check_framework_version(framework)
         framework_version = nil
-        if @version_cache.has_key?(framework)
+        if @version_cache.key?(framework)
 
           framework_version = @version_cache[framework]
         else
 
           begin
             require framework
-            framework_version = Gem.loaded_specs[framework].version.to_s
+            framework_version = Gem.loaded_specs[version_framework_name(framework)].version.to_s
           rescue LoadError => e
-            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] couldn't load #{framework} with error #{e.message}; skip"}
+            SolarWindsAPM.logger.debug do
+              "[#{self.class}/#{__method__}] couldn't load #{framework} with error #{e.message}; skip"
+            end
           rescue StandardError => e
-            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] couldn't find #{framework} with error #{e.message}; skip"}
+            SolarWindsAPM.logger.debug do
+              "[#{self.class}/#{__method__}] couldn't find #{framework} with error #{e.message}; skip"
+            end
           ensure
             @version_cache[framework] = framework_version
           end
         end
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] current framework version cached: #{@version_cache.inspect}"}
+        SolarWindsAPM.logger.debug do
+          "[#{self.class}/#{__method__}] current framework version cached: #{@version_cache.inspect}"
+        end
         framework_version
       end
 
@@ -157,21 +172,31 @@ module SolarWindsAPM
       # helper function that convert opentelemetry instrumentation name to gem library understandable
       def normalize_framework_name(framework)
         case framework
-        when "net::http"
-          normalized = "net/http"
+        when 'net::http'
+          'net/http'
+        else
+          framework
+        end
+      end
+
+      ##
+      # helper function that convert opentelemetry instrumentation name to gem library understandable
+      def version_framework_name(framework)
+        case framework
+        when 'net/http'
+          'net-http'
         else
-          normalized = framework
+          framework
         end
-        normalized
       end
 
       ##
       # Add transaction name from cache to root span then removes from cache
       def add_info_transaction_name(span_data, event)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] transaction manager: #{@txn_manager.inspect}."}
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] transaction manager: #{@txn_manager.inspect}." }
         trace_span_id = "#{span_data.hex_trace_id}-#{span_data.hex_span_id}"
         txname = @txn_manager.get(trace_span_id) || ''
-        event.addInfo("TransactionName", txname)
+        event.addInfo('TransactionName', txname)
         @txn_manager.del(trace_span_id)
       end
 
@@ -190,7 +215,7 @@ module SolarWindsAPM
           attributes.each { |key, value| event.addInfo(key, value) }
         end
 
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] exception event #{event.metadataString}"}
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] exception event #{event.metadataString}" }
         @reporter.send_report(event, with_system_timestamp: false)
       end
 
@@ -200,12 +225,12 @@ module SolarWindsAPM
         event = @context.createEvent((span_event.timestamp.to_i / 1000).to_i)
         event.addInfo('Label', 'info')
         span_event.attributes&.each { |key, value| event.addInfo(key, value) }
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] info event #{event.metadataString}"}
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] info event #{event.metadataString}" }
         @reporter.send_report(event, with_system_timestamp: false)
       end
 
       def build_meta_data(span_data, parent: false)
-        flag = span_data.trace_flags.sampled?? 1 : 0
+        flag = span_data.trace_flags.sampled? ? 1 : 0
         xtr = parent == false ? "00-#{span_data.hex_trace_id}-#{span_data.hex_span_id}-0#{flag}" : "00-#{span_data.hex_trace_id}-#{span_data.hex_parent_span_id}-0#{flag}"
         @metadata.fromString(xtr)
       end

data/lib/solarwinds_apm/opentelemetry/solarwinds_processor.rb

@@ -1,3 +1,5 @@
+# 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
@@ -8,56 +10,46 @@ module SolarWindsAPM
   module OpenTelemetry
     # reference: OpenTelemetry::SDK::Trace::SpanProcessor
     class SolarWindsProcessor
-      HTTP_METHOD      = "http.method".freeze
-      HTTP_ROUTE       = "http.route".freeze
-      HTTP_STATUS_CODE = "http.status_code".freeze
-      HTTP_URL         = "http.url".freeze
+      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(exporter, txn_manager)
-        @exporter = exporter
+      def initialize(txn_manager)
         @txn_manager = txn_manager
       end
 
       # Called when a {Span} is started, if the {Span#recording?}
       # returns true.
       #
-      # This method is called synchronously on the execution thread, should
-      # not throw or block the execution thread.
-      #
       # @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.inspect}, parent_context: #{parent_context.inspect}"
+        end
 
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] processor on_start span: #{span.inspect}, parent_context: #{parent_context.inspect}"}
-
-        parent_span = ::OpenTelemetry::Trace.current_span(parent_context)
-        return if parent_span && parent_span.context != ::OpenTelemetry::Trace::SpanContext::INVALID && parent_span.context.remote? == false
+        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}")
+        @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}"}
+        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.
       #
-      # This method is called synchronously on the execution thread, should
-      # not throw or block the execution thread.
-      # Only calculate inbound metrics for service root spans
-      #
       # @param [Span] span the {Span} that just ended.
       def on_finish(span)
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] processor on_finish span: #{span.inspect}"}
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] processor on_finish span: #{span.inspect}" }
 
-        if span.parent_span_id != ::OpenTelemetry::Trace::INVALID_SPAN_ID 
-          @exporter&.export([span.to_span_data]) if span.context.trace_flags.sampled?
-          return
-        end
+        return if non_entry_span(span: span)
 
         span_time  = calculate_span_time(start_time: span.start_timestamp, end_time: span.end_timestamp)
         domain     = nil
@@ -68,7 +60,7 @@ module SolarWindsAPM
           request_method = span.attributes[HTTP_METHOD]
           url_tran       = span.attributes[HTTP_URL]
 
-          SolarWindsAPM.logger.debug do 
+          SolarWindsAPM.logger.debug do
             "[#{self.class}/#{__method__}] createHttpSpan with\n
                                           trans_name: #{trans_name}\n
                                           url_tran: #{url_tran}\n
@@ -79,11 +71,12 @@ module SolarWindsAPM
                                           has_error: #{has_error}"
           end
 
-          liboboe_txn_name = SolarWindsAPM::Span.createHttpSpan(trans_name,url_tran,domain,span_time,status_code,request_method,has_error)
-  
+          liboboe_txn_name = SolarWindsAPM::Span.createHttpSpan(trans_name, url_tran, domain, span_time, status_code,
+                                                                request_method, has_error)
+
         else
-          
-          SolarWindsAPM.logger.debug do 
+
+          SolarWindsAPM.logger.debug do
             "[#{self.class}/#{__method__}] createSpan with \n
                                           trans_name: #{trans_name}\n
                                           domain: #{domain}\n
@@ -94,37 +87,30 @@ module SolarWindsAPM
           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}"}
-        @txn_manager["#{span.context.hex_trace_id}-#{span.context.hex_span_id}"] = liboboe_txn_name if span.context.trace_flags.sampled?
+        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)
-        @exporter&.export([span.to_span_data]) if span.context.trace_flags.sampled?
       rescue StandardError => e
-        SolarWindsAPM.logger.info {"[#{self.class}/#{__method__}] can't flush span to exporter; processor on_finish error: #{e.message}"}
-        ::OpenTelemetry::SDK::Trace::Export::FAILURE
+        SolarWindsAPM.logger.info do
+          "[#{self.class}/#{__method__}] solarwinds_processor on_finish error: #{e.message}"
+        end
       end
 
-      # Export all ended spans to the configured `Exporter` that have not yet
-      # been exported.
-      #
-      # This method should only be called in cases where it is absolutely
-      # necessary, such as when using some FaaS providers that may suspend
-      # the process after an invocation, but before the `Processor` exports
-      # the completed spans.
-      #
       # @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)
-        @exporter&.force_flush(timeout: timeout) || ::OpenTelemetry::SDK::Trace::Export::SUCCESS
+      def force_flush(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
+        ::OpenTelemetry::SDK::Trace::Export::SUCCESS
       end
 
-      # Called when {TracerProvider#shutdown} is called.
-      #
       # @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)
-        @exporter&.shutdown(timeout: timeout) || ::OpenTelemetry::SDK::Trace::Export::SUCCESS
+      def shutdown(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
+        ::OpenTelemetry::SDK::Trace::Export::SUCCESS
       end
 
       private
@@ -147,16 +133,28 @@ module SolarWindsAPM
         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 {"[#{self.class}/#{__method__}] found trans name from txn_manager: #{trans_name} by #{trace_span_id}"}
+          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.has_key?('SW_APM_TRANSACTION_NAME') && ENV['SW_APM_TRANSACTION_NAME'] != ''
-          trans_name =  ENV['SW_APM_TRANSACTION_NAME']
+        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?)

data/lib/solarwinds_apm/opentelemetry/solarwinds_propagator.rb

@@ -1,3 +1,5 @@
+# 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
@@ -10,14 +12,14 @@ module SolarWindsAPM
       # TextMapPropagator
       # propagator error will be rescued by OpenTelemetry::Context::Propagation::TextMapPropagator
       class TextMapPropagator
-        TRACESTATE_HEADER_NAME    = "tracestate".freeze
-        XTRACEOPTIONS_HEADER_NAME = "x-trace-options".freeze
-        XTRACEOPTIONS_SIGNATURE_HEADER_NAME = "x-trace-options-signature".freeze
-        INTL_SWO_X_OPTIONS_KEY    = "sw_xtraceoptions".freeze
-        INTL_SWO_SIGNATURE_KEY    = "sw_signature".freeze
+        TRACESTATE_HEADER_NAME    = 'tracestate'
+        XTRACEOPTIONS_HEADER_NAME = 'x-trace-options'
+        XTRACEOPTIONS_SIGNATURE_HEADER_NAME = 'x-trace-options-signature'
+        INTL_SWO_X_OPTIONS_KEY    = 'sw_xtraceoptions'
+        INTL_SWO_SIGNATURE_KEY    = 'sw_signature'
 
         private_constant \
-          :TRACESTATE_HEADER_NAME, :XTRACEOPTIONS_HEADER_NAME, 
+          :TRACESTATE_HEADER_NAME, :XTRACEOPTIONS_HEADER_NAME,
           :XTRACEOPTIONS_SIGNATURE_HEADER_NAME, :INTL_SWO_X_OPTIONS_KEY, :INTL_SWO_SIGNATURE_KEY
 
         # Extract trace context from the supplied carrier.
@@ -31,11 +33,11 @@ module SolarWindsAPM
         #
         # @return [Context] context updated with extracted baggage, or the original context
         #   if extraction fails
-        def extract(carrier, context: ::OpenTelemetry::Context.current, getter: ::OpenTelemetry::Context::Propagation.text_map_getter)
-
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] extract context: #{context.inspect}"}
+        def extract(carrier, context: ::OpenTelemetry::Context.current,
+                    getter: ::OpenTelemetry::Context::Propagation.text_map_getter)
+          SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] extract context: #{context.inspect}" }
 
-          context = context.nil?? ::OpenTelemetry::Context.new({}) : context
+          context = ::OpenTelemetry::Context.new({}) if context.nil?
           context = inject_extracted_header(carrier, context, getter, XTRACEOPTIONS_HEADER_NAME, INTL_SWO_X_OPTIONS_KEY)
           inject_extracted_header(carrier, context, getter, XTRACEOPTIONS_SIGNATURE_HEADER_NAME, INTL_SWO_SIGNATURE_KEY)
         end
@@ -47,31 +49,37 @@ module SolarWindsAPM
         # @param [optional Setter] setter If the optional setter is provided, it
         #   will be used to write context into the carrier, otherwise the default
         #   text map setter will be used.
-        def inject(carrier, context: ::OpenTelemetry::Context.current, setter: ::OpenTelemetry::Context::Propagation.text_map_setter)
+        def inject(carrier, context: ::OpenTelemetry::Context.current,
+                   setter: ::OpenTelemetry::Context::Propagation.text_map_setter)
+          SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] inject context: #{context.inspect}" }
 
-          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}"}
+          SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] span_context #{span_context.inspect}" }
           return unless span_context&.valid?
 
-          trace_flag = span_context.trace_flags.sampled?? 1 : 0
+          trace_flag = span_context.trace_flags.sampled? ? 1 : 0
           sw_value   = "#{span_context.hex_span_id}-0#{trace_flag}"
-          trace_state_header = carrier[TRACESTATE_HEADER_NAME].nil?? nil : carrier[TRACESTATE_HEADER_NAME]
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] sw_value: #{sw_value}; trace_state_header: #{trace_state_header}"}
+          trace_state_header = carrier[TRACESTATE_HEADER_NAME].nil? ? nil : carrier[TRACESTATE_HEADER_NAME]
+          SolarWindsAPM.logger.debug do
+            "[#{self.class}/#{__method__}] sw_value: #{sw_value}; trace_state_header: #{trace_state_header}"
+          end
 
           # prepare carrier with carrier's or new tracestate
           if trace_state_header.nil?
             # only create new trace state if valid span_id
             unless span_context.span_id == ::OpenTelemetry::Trace::INVALID_SPAN_ID
-              trace_state = ::OpenTelemetry::Trace::Tracestate.create({SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY => sw_value})
-              SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] creating new trace state: #{trace_state.inspect}"}
+              trace_state = ::OpenTelemetry::Trace::Tracestate.create({ SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY => sw_value })
+              SolarWindsAPM.logger.debug do
+                "[#{self.class}/#{__method__}] creating new trace state: #{trace_state.inspect}"
+              end
               setter.set(carrier, TRACESTATE_HEADER_NAME, Utils.trace_state_header(trace_state))
             end
           else
             trace_state_from_string = ::OpenTelemetry::Trace::Tracestate.from_string(trace_state_header)
             trace_state = trace_state_from_string.set_value(SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY, sw_value)
-            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] updating/adding trace state for injection #{trace_state.inspect}"}
+            SolarWindsAPM.logger.debug do
+              "[#{self.class}/#{__method__}] updating/adding trace state for injection #{trace_state.inspect}"
+            end
             setter.set(carrier, TRACESTATE_HEADER_NAME, Utils.trace_state_header(trace_state))
           end
         end
@@ -85,11 +93,11 @@ module SolarWindsAPM
         end
 
         private
-        
+
         def inject_extracted_header(carrier, context, getter, header, inject_key)
           extracted_header = getter.get(carrier, header)
           context = context.set_value(inject_key, extracted_header) if extracted_header
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] #{header}: #{inject_key} = #{extracted_header}"}
+          SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] #{header}: #{inject_key} = #{extracted_header}" }
           context
         end
       end