solarwinds_apm 5.1.9 → 6.0.0.preV2

data/lib/solarwinds_apm/oboe_init_options.rb

@@ -1,10 +1,9 @@
 # Copyright (c) 2019 SolarWinds, LLC.
 # All rights reserved.
-
 require 'singleton'
-
+require 'uri'
 module SolarWindsAPM
-
+  # OboeInitOptions
   class OboeInitOptions
     include Singleton
 
@@ -46,7 +45,7 @@ module SolarWindsAPM
       # custom token bucket rate
       @token_bucket_rate = (ENV['SW_APM_TOKEN_BUCKET_RATE'] || -1).to_i
       # use single files in file reporter for each event
-      @file_single = (ENV['SW_APM_REPORTER_FILE_SINGLE'].to_s.downcase == 'true') ? 1 : 0
+      @file_single = ENV['SW_APM_REPORTER_FILE_SINGLE'].to_s.downcase == 'true' ? 1 : 0
       # timeout for ec2 metadata
       @ec2_md_timeout = read_and_validate_ec2_md_timeout
       @grpc_proxy = read_and_validate_proxy
@@ -57,7 +56,8 @@ module SolarWindsAPM
       @metric_format = determine_the_metric_model
     end
 
-    def re_init # for testing with changed ENV vars
+    # for testing with changed ENV vars
+    def re_init
       initialize
     end
 
@@ -84,12 +84,12 @@ module SolarWindsAPM
         @ec2_md_timeout,         #17
         @grpc_proxy,             #18
         0,                       #19 arg for lambda (no lambda for ruby yet)
-        @metric_format           #20
+        @metric_format           #22
       ]
     end
 
     def service_key_ok?
-      return !@service_key.empty? || @reporter != 'ssl'
+      !@service_key.empty? || @reporter != 'ssl'
     end
 
     private
@@ -97,18 +97,14 @@ module SolarWindsAPM
     def reporter_and_host
 
       reporter = ENV['SW_APM_REPORTER'] || 'ssl'
-      # override with 'file', e.g. when running tests
-      # changed my mind => set the right reporter in the env when running tests !!!
-      # reporter = 'file' if ENV.key?('SW_APM_GEM_TEST')
 
       host = ''
       case reporter
       when 'ssl', 'file'
         host = ENV['SW_APM_COLLECTOR'] || ''
       when 'udp'
-        host = ENV['SW_APM_COLLECTOR'] ||
-                "#{SolarWindsAPM::Config[:reporter_host]}:#{SolarWindsAPM::Config[:reporter_port]}"
-        # TODO decide what to do
+        host = ENV['SW_APM_COLLECTOR'] || "#{SolarWindsAPM::Config[:reporter_host]}:#{SolarWindsAPM::Config[:reporter_port]}"
+        # TODO: decide what to do
         # ____ SolarWindsAPM::Config[:reporter_host] and
         # ____ SolarWindsAPM::Config[:reporter_port] were moved here from
         # ____ oboe_metal.rb and are not documented anywhere
@@ -117,6 +113,7 @@ module SolarWindsAPM
         host = ''
       end
 
+      host = sanitize_collector_uri(host) unless reporter == 'file'
       [reporter, host]
     end
 
@@ -124,25 +121,51 @@ module SolarWindsAPM
       return '' unless @reporter == 'ssl'
 
       service_key = ENV['SW_APM_SERVICE_KEY'] || SolarWindsAPM::Config[:service_key]
-      unless service_key
-        SolarWindsAPM.logger.error "[solarwinds_apm/oboe_options] SW_APM_SERVICE_KEY not configured."
+      if service_key.nil? || service_key == ''
+        SolarWindsAPM.logger.error {"[#{self.class}/#{__method__}] SW_APM_SERVICE_KEY not configured."}
         return ''
       end
 
-      match = service_key.match( /([^:]+)(:{0,1})(.*)/ )
+      match = service_key.match(/([^:]+)(:{0,1})(.*)/)
       token = match[1]
       service_name = match[3]
 
-      return '' unless validate_token(token)
+      return '' unless validate_token(token)   # return if token is not even valid
+
+      if service_name.empty?
+        ENV.delete('OTEL_SERVICE_NAME')
+        SolarWindsAPM.logger.warn {"[#{self.class}/#{__method__}] SW_APM_SERVICE_KEY format problem. Service Name is missing."}
+        return ''
+      end
+
+      # check OTEL_RESOURCE_ATTRIBUTES
+      otel_resource_service_name = nil
+      ENV['OTEL_RESOURCE_ATTRIBUTES']&.split(',')&.each do |pair|
+        key, value = pair.split('=')
+        otel_resource_service_name = value; break if key == 'service.name'
+      end
+
+      SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] provided otel_resource_service_name #{otel_resource_service_name}"} if otel_resource_service_name
+      service_name = otel_resource_service_name if otel_resource_service_name && validate_transform_service_name(otel_resource_service_name)
+
+      # check OTEL_SERVICE_NAME
+      otel_service_name = ENV['OTEL_SERVICE_NAME']
+      if otel_service_name && validate_transform_service_name(otel_service_name)
+        service_name = otel_service_name
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] provided otel_service_name #{otel_service_name}"}
+      elsif ENV['OTEL_SERVICE_NAME'].nil?
+        ENV['OTEL_SERVICE_NAME'] = service_name
+      end
+
       return '' unless validate_transform_service_name(service_name)
 
-      return "#{token}:#{service_name}"
+      "#{token}:#{service_name}"
     end
 
     def validate_token(token)
       if (token !~ /^[0-9a-zA-Z_-]{71}$/) && ENV['SW_APM_COLLECTOR'] !~ /java-collector:1222/
-        masked = "#{token[0..3]}...#{token[-4..-1]}"
-        SolarWindsAPM.logger.error "[solarwinds_apm/oboe_options] SW_APM_SERVICE_KEY problem. API Token in wrong format. Masked token: #{masked}"
+        masked = "#{token[0..3]}...#{token[-4..]}"
+        SolarWindsAPM.logger.error {"[#{self.class}/#{__method__}] SW_APM_SERVICE_KEY problem. API Token in wrong format. Masked token: #{masked}"}
         return false
       end
 
@@ -152,7 +175,7 @@ module SolarWindsAPM
     def validate_transform_service_name(service_name)
       service_name = 'test_ssl_collector' if ENV['SW_APM_COLLECTOR'] =~ /java-collector:1222/
       if service_name.empty?
-        SolarWindsAPM.logger.error "[solarwinds_apm/oboe_options] SW_APM_SERVICE_KEY problem. Service Name is missing"
+        SolarWindsAPM.logger.error {"[#{self.class}/#{__method__}] SW_APM_SERVICE_KEY problem. Service Name is missing"}
         return false
       end
 
@@ -162,7 +185,7 @@ module SolarWindsAPM
       name = name[0..254]
 
       if name != service_name
-        SolarWindsAPM.logger.warn "[solarwinds_apm/oboe_options] SW_APM_SERVICE_KEY problem. Service Name transformed from #{service_name} to #{name}"
+        SolarWindsAPM.logger.warn {"[#{self.class}/#{__method__}] SW_APM_SERVICE_KEY problem. Service Name transformed from #{service_name} to #{name}"}
         service_name = name
       end
       @service_name = service_name # instance variable used in testing
@@ -172,8 +195,9 @@ module SolarWindsAPM
     def read_and_validate_ec2_md_timeout
       timeout = ENV['SW_APM_EC2_METADATA_TIMEOUT'] || SolarWindsAPM::Config[:ec2_metadata_timeout]
       return 1000 unless timeout.is_a?(Integer) || timeout =~ /^\d+$/
+
       timeout = timeout.to_i
-      return timeout.between?(0, 3000) ? timeout : 1000
+      timeout.between?(0, 3000) ? timeout : 1000
     end
 
     def read_and_validate_proxy
@@ -181,7 +205,7 @@ module SolarWindsAPM
       return proxy if proxy == ''
 
       unless proxy =~ /http:\/\/.*:\d+$/
-        SolarWindsAPM.logger.error "[solarwinds_apm/oboe_options] SW_APM_PROXY/http_proxy doesn't start with 'http://', #{proxy}"
+        SolarWindsAPM.logger.error {"[#{self.class}/#{__method__}] SW_APM_PROXY/http_proxy doesn't start with 'http://', #{proxy}"}
         return '' # try without proxy, it may work, shouldn't crash but may not report
       end
 
@@ -189,31 +213,43 @@ module SolarWindsAPM
     end
 
     def read_certificates
+      file = String.new
+      file = "#{__dir__}/cert/star.appoptics.com.issuer.crt" if appoptics_collector?
+      file = ENV['SW_APM_TRUSTEDPATH'] if !ENV['SW_APM_TRUSTEDPATH'].nil? && !ENV['SW_APM_TRUSTEDPATH']&.empty?
+
+      return file if file.empty?
 
-      file = ''
-      file = "#{File.expand_path File.dirname(__FILE__)}/cert/star.appoptics.com.issuer.crt" if ENV["SW_APM_COLLECTOR"]&.include? "appoptics.com"
-      file = ENV['SW_APM_TRUSTEDPATH'] if (!ENV['SW_APM_TRUSTEDPATH'].nil? && !ENV['SW_APM_TRUSTEDPATH']&.empty?)
-      
-      return String.new if file.empty?
-      
       begin
         certificate = File.open(file,"r").read
       rescue StandardError => e
-        SolarWindsAPM.logger.error "[solarwinds_apm/oboe_options] certificates: #{file} doesn't exist or caused by #{e.message}."
+        SolarWindsAPM.logger.error {"[#{self.class}/#{__method__}] certificates: #{file} doesn't exist or caused by #{e.message}."}
         certificate = String.new
       end
-      
-      return certificate
 
+      certificate
     end
 
     def determine_the_metric_model
-      if ENV['SW_APM_COLLECTOR']&.include? "appoptics.com"
-        return 1
-      else
-        return 0
+      appoptics_collector? ? 1 : 2
+    end
+
+    def appoptics_collector?
+      allowed_uri = ['collector.appoptics.com', 'collector-stg.appoptics.com',
+                     'collector.appoptics.com:443', 'collector-stg.appoptics.com:443']
+
+      (allowed_uri.include? ENV["SW_APM_COLLECTOR"])? true : false
+    end
+
+    def sanitize_collector_uri(uri)
+      return uri if uri.nil? || uri.empty?
+
+      begin
+        sanitized_uri = ::URI.parse("http://#{uri}").host
+        return sanitized_uri unless sanitized_uri.nil?
+      rescue StandardError => e
+        SolarWindsAPM.logger.error {"[#{self.class}/#{__method__}] uri for collector #{uri} is malformat. Error: #{e.message}"}
       end
+      ""
     end
   end
 end
-

data/lib/solarwinds_apm/opentelemetry/solarwinds_exporter.rb

@@ -0,0 +1,204 @@
+# solarwinds_apm will use liboboe to export data to solarwinds swo
+module SolarWindsAPM
+  module OpenTelemetry
+    # SolarWindsExporter
+    class SolarWindsExporter
+      SUCCESS = ::OpenTelemetry::SDK::Trace::Export::SUCCESS # ::OpenTelemetry  #=> the OpenTelemetry at top level (to ignore SolarWindsAPM)
+      FAILURE = ::OpenTelemetry::SDK::Trace::Export::FAILURE
+
+      private_constant(:SUCCESS, :FAILURE)
+    
+      def initialize(txn_manager: nil)
+        @shutdown           = false
+        @txn_manager        = txn_manager
+        @reporter           = SolarWindsAPM::Reporter
+        @context            = SolarWindsAPM::Context
+        @metadata           = SolarWindsAPM::Metadata
+        @version_cache      = {}
+      end
+
+      def export(span_data, _timeout: nil)
+        return FAILURE if @shutdown
+        
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] span_data: #{span_data}"}
+        span_data.each do |data|
+          log_span_data(data)
+        end
+        SUCCESS
+      end
+
+      def force_flush(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
+        SUCCESS
+      end
+
+      def shutdown(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
+        @shutdown = true
+        SUCCESS
+      end
+
+      private
+
+      def log_span_data(span_data)
+
+        begin
+          md = build_meta_data(span_data)
+          event = nil
+
+          if span_data.parent_span_id != ::OpenTelemetry::Trace::INVALID_SPAN_ID 
+
+            parent_md = build_meta_data(span_data, parent: true)
+            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Continue trace from parent. parent_md: #{parent_md}, span_data: #{span_data.inspect}"}
+            event = @context.createEntry(md, (span_data.start_timestamp.to_i / 1000).to_i, parent_md)
+          else
+
+            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}]  Start a new trace."}
+            event = @context.createEntry(md, (span_data.start_timestamp.to_i / 1000).to_i) 
+            add_info_transaction_name(span_data, event)
+          end
+          
+          event.addInfo('Layer', span_data.name)
+          event.addInfo('sw.span_kind', span_data.kind.to_s)
+          event.addInfo('Language', 'Ruby')
+          
+          add_info_instrumentation_scope(event, span_data)
+          add_info_instrumented_framework(event, span_data)
+
+          if span_data.attributes
+            if span_data.attributes['http.target']
+              http_target = span_data.attributes['http.target']
+              http_target = http_target.split('?').first if SolarWindsAPM::Config[:log_args] == false # remove url parameters
+              event.addInfo('http.target', http_target)
+              span_data.attributes.each do |k, v|
+                next if k == 'http.target'
+                
+                event.addInfo(k, v)
+              end
+            else
+              span_data.attributes.each { |k, v| event.addInfo(k, v) }
+            end
+          end
+
+          @reporter.send_report(event, with_system_timestamp: false)
+
+          # info / exception event
+          span_data.events&.each do |span_data_event|
+            span_data_event.name == 'exception' ? report_exception_event(span_data_event) : report_info_event(span_data_event)
+          end
+
+          event = @context.createExit((span_data.end_timestamp.to_i / 1000).to_i)
+          event.addInfo('Layer', span_data.name)
+          @reporter.send_report(event, with_system_timestamp: false)
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Exit a trace: #{event.metadataString}"}
+        rescue StandardError => e
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] \n #{e.message} #{e.backtrace}\n"}
+          raise
+        end
+
+      end
+
+      def add_info_instrumentation_scope(event, span_data)
+        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)
+      end
+
+      # 
+      # get the framework version (the real version not the sdk instrumentation version)
+      # 
+      def add_info_instrumented_framework(event, span_data)
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] add_info_instrumented_framework: #{span_data.instrumentation_scope.name}"}
+        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 if framework.nil? || framework.empty?
+        
+        framework         = normalize_framework_name(framework)
+        framework_version = check_framework_version(framework)
+        event.addInfo("Ruby.#{framework}.Version",framework_version) unless framework_version.nil?
+      end
+
+      def check_framework_version(framework)
+        framework_version = nil
+        if @version_cache.keys.include? framework
+
+          framework_version = @version_cache[framework]
+        else
+
+          begin
+            require framework
+            framework_version = Gem.loaded_specs[framework].version.to_s
+          rescue LoadError => e
+            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] couldn't load #{framework} with error #{e.message}; skip"}
+          rescue StandardError => e
+            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] couldn't find #{framework} with error #{e.message}; skip"}
+          ensure
+            @version_cache[framework] = framework_version
+          end
+        end
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Current framework version cached: #{@version_cache.inspect}"}
+        framework_version
+      end
+
+      def normalize_framework_name(framework)
+        case framework
+        when "net::http"
+          normalized = "net/http"
+        else
+          normalized = framework
+        end
+        normalized
+      end
+
+      # Add transaction name from cache to root span then removes from cache
+      def add_info_transaction_name(span_data, evt)
+        trace_span_id = "#{span_data.hex_trace_id}-#{span_data.hex_span_id}"
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] #{@txn_manager.inspect},\n span_data: #{span_data.inspect}"}
+        txname = @txn_manager.get(trace_span_id).nil?? "" : @txn_manager.get(trace_span_id)
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] txname: #{txname}"}
+        evt.addInfo("TransactionName", txname)
+        @txn_manager.del(trace_span_id)
+      end
+
+      def report_exception_event(span_event)
+        evt = @context.createEvent((span_event.timestamp.to_i / 1000).to_i)
+        evt.addInfo('Label', 'error')
+        evt.addInfo('Spec', 'error')
+
+        unless span_event.attributes.nil?
+          evt.addInfo('ErrorClass', span_event.attributes['exception.type'])
+          evt.addInfo('ErrorMsg', span_event.attributes['exception.message'])
+          evt.addInfo('Backtrace', span_event.attributes['exception.stacktrace'])
+          span_event.attributes.each do |key, value|
+            evt.addInfo(key, value) unless ['exception.type', 'exception.message','exception.stacktrace'].include? key
+          end
+        end
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] exception event #{evt.metadataString}"}
+        @reporter.send_report(evt, with_system_timestamp: false)
+      end
+
+      def report_info_event(span_event)
+        evt = @context.createEvent((span_event.timestamp.to_i / 1000).to_i)
+        evt.addInfo('Label', 'info')
+        span_event.attributes&.each do |key, value|
+          evt.addInfo(key, value)
+        end
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] info event #{evt.metadataString}"}
+        @reporter.send_report(evt, with_system_timestamp: false)
+      end
+
+      def build_meta_data(span_data, parent: false)
+        flag = span_data.trace_flags.sampled?? 1 : 0
+        version = "00"
+        xtr = parent == false ? "#{version}-#{span_data.hex_trace_id}-#{span_data.hex_span_id}-0#{flag}" : "#{version}-#{span_data.hex_trace_id}-#{span_data.hex_parent_span_id}-0#{flag}"
+        @metadata.fromString(xtr)
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/opentelemetry/solarwinds_processor.rb

@@ -0,0 +1,166 @@
+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
+      LIBOBOE_HTTP_SPAN_STATUS_UNAVAILABLE = 0
+
+      attr_reader :txn_manager
+
+      def initialize(exporter, txn_manager)
+        @exporter = exporter
+        @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 {"[#{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
+
+        trace_flags = span.context.trace_flags.sampled? ? '01' : '00'
+        ::OpenTelemetry::Context.attach(::OpenTelemetry::Baggage.set_value(::SolarWindsAPM::Constants::INTL_SWO_CURRENT_TRACE_ID, span.context.hex_trace_id))
+        ::OpenTelemetry::Context.attach(::OpenTelemetry::Baggage.set_value(::SolarWindsAPM::Constants::INTL_SWO_CURRENT_SPAN_ID, span.context.hex_span_id))
+        ::OpenTelemetry::Context.attach(::OpenTelemetry::Baggage.set_value(::SolarWindsAPM::Constants::INTL_SWO_CURRENT_TRACE_FLAG, trace_flags))
+        
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] current baggage values: #{::OpenTelemetry::Baggage.values}"}
+      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) 
+        if span.parent_span_id != ::OpenTelemetry::Trace::INVALID_SPAN_ID 
+          @exporter&.export([span.to_span_data]) if span.context.trace_flags.sampled?
+          return
+        end
+
+        span_time  = calculate_span_time(start_time: span.start_timestamp, end_time: span.end_timestamp)
+        domain     = nil
+        has_error  = error?(span)
+        trans_name = calculate_transaction_names(span)
+        url_tran   = span.attributes[HTTP_URL]
+
+        liboboe_txn_name = nil
+        if span_http?(span)
+          status_code = get_http_status_code(span)
+          request_method = span.attributes[HTTP_METHOD]
+
+          SolarWindsAPM.logger.debug do 
+            "[#{self.class}/#{__method__}] createHttpSpan with\n
+                                          trans_name: #{trans_name}\n
+                                          url_tran: #{url_tran}\n
+                                          domain: #{domain}\n
+                                          span_time: #{span_time}\n
+                                          status_code: #{status_code}\n
+                                          request_method: #{request_method}\n
+                                          has_error: #{has_error}"
+          end
+
+          liboboe_txn_name = SolarWindsAPM::Span.createHttpSpan(trans_name,url_tran,domain,span_time,status_code,request_method,has_error)
+  
+        else
+          
+          SolarWindsAPM.logger.debug do 
+            "[#{self.class}/#{__method__}] createSpan with \n
+                                          trans_name: #{trans_name}\n
+                                          domain: #{domain}\n
+                                          span_time: #{span_time}\n
+                                          has_error: #{has_error}"
+          end
+
+          liboboe_txn_name = SolarWindsAPM::Span.createSpan(trans_name, domain, span_time, has_error)
+        end
+
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] liboboe_txn_name: #{liboboe_txn_name}"}
+        @txn_manager["#{span.context.hex_trace_id}-#{span.context.hex_span_id}"] = liboboe_txn_name if span.context.trace_flags.sampled?
+
+        @exporter&.export([span.to_span_data]) if span.context.trace_flags.sampled?
+      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::Metrics::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::Metrics::Export::SUCCESS
+      end
+
+      private
+
+      # This span from inbound HTTP request if from a SERVER by some http.method
+      def span_http?(span)
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] span.kind #{span.kind}  span.attributes: #{span.attributes[HTTP_METHOD]}"}
+        (span.kind == ::OpenTelemetry::Trace::SpanKind::SERVER && !span.attributes[HTTP_METHOD].nil?)
+      end
+
+      # Calculate if this span instance has_error
+      # return [Integer]
+      def error?(span)
+        span.status.code == ::OpenTelemetry::Trace::Status::ERROR ? 1 : 0
+      end
+
+      # Calculate HTTP status_code from span or default to UNAVAILABLE
+      # Something went wrong in OTel or instrumented service crashed early
+      # if no status_code in attributes of HTTP span
+      def get_http_status_code(span)
+        span.attributes[HTTP_STATUS_CODE] || LIBOBOE_HTTP_SPAN_STATUS_UNAVAILABLE
+      end
+
+      # Get trans_name and url_tran of this span instance.
+      def calculate_transaction_names(span)
+
+        trace_span_id = "#{span.context.hex_trace_id}-#{span.context.hex_span_id}"
+        if @txn_manager.get(trace_span_id)
+          trans_name = @txn_manager.get(trace_span_id)
+        else
+          trans_name = span.attributes[HTTP_ROUTE] || nil
+          trans_name = span.name if span.name && (trans_name.nil? || trans_name.empty?)
+        end
+        trans_name
+      end
+
+      # Calculate span time in microseconds (us) using start and end time
+      # in nanoseconds (ns). OTel span start/end_time are optional.
+      def calculate_span_time(start_time: nil, end_time: nil)
+        return 0 if start_time.nil? || end_time.nil?
+
+        ((end_time.to_i - start_time.to_i) / 1e3).round
+      end
+    end
+  end
+end