solarwinds_apm 6.1.2 → 7.0.0.prev1

data/lib/oboe_metal.rb

@@ -1,187 +0,0 @@
-# frozen_string_literal: true
-
-# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at:http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
-
-# Disable docs and Camelcase warns since we're implementing
-# an interface here.  See OboeBase for details.
-module SolarWindsAPM
-  include Oboe_metal
-
-  @loaded    = false
-  @reporter  = nil
-  @oboe_api  = nil
-  @init_sent = false
-
-  class << self
-    attr_accessor :reporter, :loaded, :oboe_api, :init_sent
-
-    def sample_rate(rate)
-      return unless SolarWindsAPM.loaded
-
-      # Update liboboe with the new SampleRate value
-      SolarWindsAPM::Context.setDefaultSampleRate(rate.to_i)
-    end
-  end
-
-  # Reporter that send span data to SWO
-  class Reporter
-    class << self
-      ##
-      # start
-      #
-      # Start the SolarWindsAPM Reporter
-      #
-      def start
-        options = SolarWindsAPM::OboeInitOptions.instance.array_for_oboe # creates an array with the options in the right order
-        SolarWindsAPM.reporter = Oboe_metal::Reporter.new(*options)
-        SolarWindsAPM.loaded = true
-        report_init if (options[22]).zero? # report init at beginning if no after fork enabled
-      rescue StandardError => e
-        warn e.message
-        SolarWindsAPM.loaded = false
-      end
-      alias restart start
-
-      ##
-      # sendReport
-      #
-      # Send the report for the given event
-      #
-      def send_report(evt, with_system_timestamp: true)
-        SolarWindsAPM.reporter.sendReport(evt, with_system_timestamp)
-      end
-
-      ##
-      # sendStatus
-      #
-      # Send the report for the given event
-      #
-      def send_status(evt, context = nil, with_system_timestamp: true)
-        SolarWindsAPM.reporter.sendStatus(evt, context, with_system_timestamp)
-      end
-
-      private
-
-      # Internal: Report that instrumentation for the given layer has been
-      # installed, as well as the version of instrumentation and version of
-      # layer.
-      #
-      def report_init(layer = :rack) # :nodoc:
-        # Don't send __Init in test or if SolarWindsAPM isn't fully loaded (e.g. missing c-extension)
-        # or if already sent (e.g. SolarWindsAPM.init_sent = true)
-        return if SolarWindsAPM.init_sent
-        return unless SolarWindsAPM.loaded
-
-        platform_info = build_swo_init_report
-        log_init(layer, platform_info)
-
-        SolarWindsAPM.init_sent = true
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] Init message has been sent." }
-      end
-
-      ##
-      # :nodoc:
-      # Internal: Reports agent init to the collector
-      #
-      # ==== Arguments
-      #
-      # * +layer+ - The layer the reported event belongs to
-      # * +kvs+ - A hash containing key/value pairs that will be reported along with this event
-      def log_init(layer = :rack, kvs = {})
-        context = SolarWindsAPM::Metadata.makeRandom
-        return SolarWindsAPM::Context.toString unless context.isValid
-
-        event = context.createEvent
-        event.addInfo('Layer', layer.to_s)
-        event.addInfo('Label', 'single')
-        kvs.each do |k, v|
-          event.addInfo(k, v.to_s)
-        end
-
-        SolarWindsAPM::Reporter.send_status(event, context, with_system_timestamp: true)
-        SolarWindsAPM::Context.toString
-      end
-
-      ##
-      #  build_swo_init_report
-      #
-      # Internal: Build a hash of KVs that reports on the status of the
-      # running environment for swo only. This is used on stack boot in __Init reporting
-      # and for SolarWindsAPM.support_report.
-      #
-      def build_swo_init_report
-        platform_info = { '__Init' => true }
-
-        begin
-          platform_info['APM.Version']             = SolarWindsAPM::Version::STRING
-          platform_info['APM.Extension.Version']   = extension_lib_version
-
-          # OTel Resource Attributes (Optional)
-          platform_info['process.executable.path'] =
-            File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name']).sub(/.*\s.*/m, '"\&"')
-          platform_info['process.executable.name'] = RbConfig::CONFIG['ruby_install_name']
-          platform_info['process.command_line']    = $PROGRAM_NAME
-          platform_info['process.telemetry.path']  = Gem::Specification.find_by_name('solarwinds_apm')&.full_gem_path
-          platform_info['os.type']                 = RUBY_PLATFORM
-
-          platform_info.merge!(report_gem_in_use)
-
-          # Collect up opentelemetry sdk version (Instrumented Library Versions) (Required)
-          begin
-            require 'opentelemetry/sdk'
-            ::OpenTelemetry::SDK::Resources::Resource.telemetry_sdk.attribute_enumerator.each do |k, v|
-              platform_info[k] = v
-            end
-            ::OpenTelemetry::SDK::Resources::Resource.process.attribute_enumerator.each { |k, v| platform_info[k] = v }
-          rescue StandardError => e
-            SolarWindsAPM.logger.warn do
-              "[#{self.class}/#{__method__}] Fail to extract telemetry attributes. Error: #{e.message}"
-            end
-          end
-        rescue StandardError, ScriptError => e
-          # Also rescue ScriptError (aka SyntaxError) in case one of the expected
-          # version defines don't exist
-
-          platform_info['Error'] = "Error in build_report: #{e.message}"
-
-          SolarWindsAPM.logger.warn { "[#{self.class}/#{__method__}] Error in build_init_report: #{e.message}" }
-          SolarWindsAPM.logger.debug { e.backtrace }
-        end
-        platform_info
-      end
-
-      ##
-      # Collect up the loaded gems
-      ##
-      def report_gem_in_use
-        platform_info = {}
-        if defined?(Gem) && Gem.respond_to?(:loaded_specs)
-          Gem.loaded_specs.each_pair { |k, v| platform_info["Ruby.#{k}.Version"] = v.version.to_s }
-        else
-          platform_info.merge!(legacy_build_init_report)
-        end
-        platform_info
-      end
-
-      ##
-      # get extension library version by looking at the VERSION file
-      # oboe not loaded yet, can't use oboe_api function to read oboe VERSION
-      ##
-      def extension_lib_version
-        gem_location = Gem::Specification.find_by_name('solarwinds_apm')
-        clib_version_file = File.join(gem_location&.gem_dir, 'ext', 'oboe_metal', 'src', 'VERSION')
-        File.read(clib_version_file).strip
-      end
-    end
-  end
-end
-
-# Setup an alias
-SolarWindsApm = SolarWindsAPM
-SolarwindsApm = SolarWindsAPM
-SolarwindsAPM = SolarWindsAPM
-Solarwindsapm = SolarWindsAPM

data/lib/solarwinds_apm/cert/star.appoptics.com.issuer.crt

@@ -1,24 +0,0 @@
------BEGIN CERTIFICATE-----
-MIID8TCCAtmgAwIBAgIJAMoDz7Npas2/MA0GCSqGSIb3DQEBCwUAMIGOMQswCQYD
-VQQGEwJVUzETMBEGA1UECAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNU2FuIEZyYW5j
-aXNjbzEVMBMGA1UECgwMTGlicmF0byBJbmMuMRUwEwYDVQQDDAxBcHBPcHRpY3Mg
-Q0ExJDAiBgkqhkiG9w0BCQEWFXN1cHBvcnRAYXBwb3B0aWNzLmNvbTAeFw0xNzA5
-MTUyMjAxMzlaFw0yNzA5MTMyMjAxMzlaMIGOMQswCQYDVQQGEwJVUzETMBEGA1UE
-CAwKQ2FsaWZvcm5pYTEWMBQGA1UEBwwNU2FuIEZyYW5jaXNjbzEVMBMGA1UECgwM
-TGlicmF0byBJbmMuMRUwEwYDVQQDDAxBcHBPcHRpY3MgQ0ExJDAiBgkqhkiG9w0B
-CQEWFXN1cHBvcnRAYXBwb3B0aWNzLmNvbTCCASIwDQYJKoZIhvcNAQEBBQADggEP
-ADCCAQoCggEBAOxO0wsGba3iI4r3L5BMST0rAO/gGaUhpQre6nRwVTmPCnLw1bmn
-GdiFgYv/oRRwU+VieumHSQqoOmyFrg+ajGmvUDp2WqQ0It+XhcbaHFiAp2H7+mLf
-cUH6S43/em0WUxZHeRzRupRDyO1bX6Hh2jgxykivlFrn5HCIQD5Hx1/SaZoW9v2n
-oATCbgFOiPW6kU/AVs4R0VBujon13HCehVelNKkazrAEBT1i6RvdOB6aQQ32seW+
-gLV5yVWSPEJvA9ZJqad/nQ8EQUMSSlVN191WOjp4bGpkJE1svs7NmM+Oja50W56l
-qOH5eWermr/8qWjdPlDJ+I0VkgN0UyHVuRECAwEAAaNQME4wHQYDVR0OBBYEFOuL
-KDTFhRQXwlBRxhPqhukrNYeRMB8GA1UdIwQYMBaAFOuLKDTFhRQXwlBRxhPqhukr
-NYeRMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAJQtH446NZhjusy6
-iCyvmnD95ybfNPDpjHmNx5n9Y6w9n+9y1o3732HUJE+WjvbLS3h1o7wujGKMcRJn
-7I7eTDd26ZhLvnh5/AitYjdxrtUkQDgyxwLFJKhZu0ik2vXqj0fL961/quJL8Gyp
-hNj3Nf7WMohQMSohEmCCX2sHyZGVGYmQHs5omAtkH/NNySqmsWNcpgd3M0aPDRBZ
-5VFreOSGKBTJnoLNqods/S9RV0by84hm3j6aQ/tMDIVE9VCJtrE6evzC0MWyVFwR
-ftgwcxyEq5SkiR+6BCwdzAMqADV37TzXDHLjwSrMIrgLV5xZM20Kk6chxI5QAr/f
-7tsqAxw=
------END CERTIFICATE-----

data/lib/solarwinds_apm/oboe_init_options.rb

@@ -1,222 +0,0 @@
-# frozen_string_literal: true
-
-# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at:http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
-
-require 'singleton'
-require 'uri'
-
-require_relative 'support/service_key_checker'
-
-module SolarWindsAPM
-  # OboeInitOptions
-  class OboeInitOptions
-    include Singleton
-
-    attr_reader :reporter, :host, :service_name, :ec2_md_timeout, :grpc_proxy, :lambda_env # exposing these mainly for testing
-
-    def initialize
-      # determining the lambda env based on env var (not used in array_for_oboe for oboe initialization)
-      @lambda_env = determine_lambda
-      # optional hostname alias
-      @hostname_alias = ENV['SW_APM_HOSTNAME_ALIAS'] || SolarWindsAPM::Config[:hostname_alias] || ''
-      # level at which log messages will be written to log file (0-6)
-      @debug_level = (ENV['SW_APM_DEBUG_LEVEL'] || SolarWindsAPM::Config[:debug_level] || 3).to_i
-      # file name including path for log file
-      # TODO eventually find better way to combine ruby and oboe logs
-      @log_file_path = ENV['SW_APM_LOG_FILEPATH'] || ''
-      # maximum number of transaction names to track
-      @max_transactions = (ENV['SW_APM_MAX_TRANSACTIONS'] || -1).to_i
-      # maximum wait time for flushing data before terminating in milli seconds
-      @max_flush_wait_time = (ENV['SW_APM_FLUSH_MAX_WAIT_TIME'] || -1).to_i
-      # events flush timeout in seconds (threshold for batching messages before sending off)
-      @events_flush_interval = (ENV['SW_APM_EVENTS_FLUSH_INTERVAL'] || -1).to_i
-      # events flush batch size in KB (threshold for batching messages before sending off)
-      @event_flush_batch_size = (ENV['SW_APM_EVENTS_FLUSH_BATCH_SIZE'] || -1).to_i
-
-      # the reporter to be used (ssl, upd, file, null)
-      # collector endpoint (reporter=ssl), udp address (reporter=udp), or file path (reporter=file)
-      @reporter, @host = reporter_and_host
-
-      # the service key
-      @service_key = read_and_validate_service_key
-      # certificate content
-      @certificates = read_certificates
-      # size of the message buffer
-      @buffer_size = (ENV['SW_APM_BUFSIZE'] || -1).to_i
-      # flag indicating if trace metrics reporting should be enabled (default) or disabled
-      @trace_metrics = (ENV['SW_APM_TRACE_METRICS'] || -1).to_i
-      # the histogram precision (only for ssl)
-      @histogram_precision = (ENV['SW_APM_HISTOGRAM_PRECISION'] || -1).to_i
-      # custom token bucket capacity
-      @token_bucket_capacity = (ENV['SW_APM_TOKEN_BUCKET_CAPACITY'] || -1).to_i
-      # 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.casecmp('true').zero? ? 1 : 0
-      # timeout for ec2 metadata
-      @ec2_md_timeout = read_and_validate_ec2_md_timeout
-      @grpc_proxy = read_and_validate_proxy
-      # hardcoded arg for lambda (lambda not supported yet)
-      # hardcoded arg for grpc hack
-      # hardcoded arg for trace id format to use w3c format
-      # flag for format of metric (0 = Both; 1 = AppOptics only; 2 = SWO only; default = 0)
-      @metric_format = determine_the_metric_model
-      # log type (0 = stderr; 1 = stdout; 2 = file; 3 = null; 4 = disabled; default = 0)
-      @log_type = determine_oboe_log_type
-      # after fork enablement (0 = disable; 1 = enabled, parent process will not init oboe but fork child process will init oboe; default = 0)
-      @after_fork = determine_oboe_after_fork
-    end
-
-    # for testing with changed ENV vars
-    def re_init
-      initialize
-    end
-
-    def array_for_oboe
-      [
-        @hostname_alias,         # 0
-        @debug_level,            # 1
-        @log_file_path,          # 2
-        @max_transactions,       # 3
-        @max_flush_wait_time,    # 4
-        @events_flush_interval,  # 5
-        @event_flush_batch_size, # 6
-        @reporter,               # 7
-        @host,                   # 8
-        @service_key,            # 9
-        @certificates,           # 10
-        @buffer_size,            # 11
-        @trace_metrics,          # 12
-        @histogram_precision,    # 13
-        @token_bucket_capacity,  # 14
-        @token_bucket_rate,      # 15
-        @file_single,            # 16
-        @ec2_md_timeout,         # 17
-        @grpc_proxy,             # 18
-        0,                       # 19 arg for lambda (no lambda for ruby yet)
-        @metric_format,          # 20
-        @log_type,               # 21
-        @after_fork              # 22
-      ]
-    end
-
-    def service_key_ok?
-      !@service_key.empty? || @reporter != 'ssl'
-    end
-
-    private
-
-    def reporter_and_host
-      reporter = ENV['SW_APM_REPORTER'] || 'ssl'
-
-      host = case reporter
-             when 'ssl', 'file'
-               ENV['SW_APM_COLLECTOR'] || ''
-             else
-               ''
-             end
-
-      host = sanitize_collector_uri(host) unless reporter == 'file'
-      [reporter, host]
-    end
-
-    def read_and_validate_service_key
-      service_key_checker = SolarWindsAPM::ServiceKeyChecker.new(@reporter, @lambda_env)
-      service_key = service_key_checker.read_and_validate_service_key
-      @service_name = service_key.split(':', 2).last # instance variable used in testing
-      service_key
-    end
-
-    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
-      timeout.between?(0, 3000) ? timeout : 1000
-    end
-
-    def read_and_validate_proxy
-      proxy = ENV['SW_APM_PROXY'] || SolarWindsAPM::Config[:http_proxy] || ''
-      return proxy if proxy == ''
-
-      unless %r{http://.*:\d+$}.match?(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
-
-      proxy
-    end
-
-    def read_certificates
-      certificate = ''
-
-      file = appoptics_collector? ? "#{__dir__}/cert/star.appoptics.com.issuer.crt" : ENV.fetch('SW_APM_TRUSTEDPATH', nil)
-      return certificate if file.nil? || file&.empty?
-
-      begin
-        certificate = File.read(file)
-      rescue StandardError => e
-        SolarWindsAPM.logger.error do
-          "[#{self.class}/#{__method__}] certificates: #{file} doesn't exist or caused by #{e.message}."
-        end
-      end
-
-      certificate
-    end
-
-    def determine_the_metric_model
-      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.fetch('SW_APM_COLLECTOR', nil))
-    end
-
-    def java_collector?(uri)
-      java_collector_regex = /java-collector:\d+/
-      uri.match?(java_collector_regex)
-    end
-
-    def sanitize_collector_uri(uri)
-      return uri if uri.nil? || uri.empty?
-      return uri if java_collector?(uri)
-
-      begin
-        sanitized_uri = ::URI.parse("http://#{uri}").host
-        return sanitized_uri unless sanitized_uri.nil?
-      rescue StandardError => e
-        SolarWindsAPM.logger.error do
-          "[#{self.class}/#{__method__}] uri for collector #{uri} is malformat. Error: #{e.message}"
-        end
-      end
-      ''
-    end
-
-    def determine_oboe_log_type
-      log_type = 0
-      log_type = 2 unless ENV['SW_APM_LOG_FILEPATH'].to_s.empty?
-      log_type = 4 if @debug_level == -1
-      log_type
-    end
-
-    def determine_lambda
-      if ENV['LAMBDA_TASK_ROOT'].to_s.empty? && ENV['AWS_LAMBDA_FUNCTION_NAME'].to_s.empty?
-        false
-      else
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] lambda environment - LAMBDA_TASK_ROOT: #{ENV.fetch('LAMBDA_TASK_ROOT', nil)}; AWS_LAMBDA_FUNCTION_NAME: #{ENV.fetch('AWS_LAMBDA_FUNCTION_NAME', nil)}" }
-        true
-      end
-    end
-
-    def determine_oboe_after_fork
-      ENV['SW_APM_ENABLE_AFTER_FORK'].to_s == 'true' ? 1 : 0
-    end
-  end
-end

data/lib/solarwinds_apm/opentelemetry/solarwinds_exporter.rb

@@ -1,239 +0,0 @@
-# frozen_string_literal: true
-
-# © 2023 SolarWinds Worldwide, LLC. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at:http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
-
-module SolarWindsAPM
-  module OpenTelemetry
-    # 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) # rubocop:disable Lint/UnusedMethodArgument
-        return FAILURE if @shutdown
-
-        status = SUCCESS
-        span_data.each do |data|
-          status = log_span_data(data)
-        end
-
-        status
-      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)
-        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
-          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 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')
-        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)
-
-        # 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', layer_name)
-        @reporter.send_report(event, with_system_timestamp: false)
-        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" }
-        FAILURE
-      end
-
-      ##
-      # extract the span_data.attributes (OpenTelemetry::SDK::Trace::SpanData.attributes)
-      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
-        attributes.each { |k, v| event.addInfo(k, v) }
-        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 = ''
-        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
-
-      ##
-      # add the gem library version to event
-      # p.s. gem library version is not same as the opentelemetry-instrumentation-* gem version
-      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 if framework.nil? || framework.empty?
-
-        framework         = normalize_framework_name(framework)
-        framework_version = check_framework_version(framework)
-        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.key?(framework)
-
-          framework_version = @version_cache[framework]
-        else
-
-          begin
-            require framework
-            framework_version = Gem.loaded_specs[version_framework_name(framework)].version.to_s
-          rescue LoadError => e
-            SolarWindsAPM.logger.debug do
-              "[#{self.class}/#{__method__}] couldn't load #{framework} with error #{e.message}; skip"
-            end
-          rescue StandardError => e
-            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 do
-          "[#{self.class}/#{__method__}] current framework version cached: #{@version_cache.inspect}"
-        end
-        framework_version
-      end
-
-      ##
-      # helper function that convert opentelemetry instrumentation name to gem library understandable
-      def normalize_framework_name(framework)
-        case framework
-        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
-          framework
-        end
-      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}." }
-        trace_span_id = "#{span_data.hex_trace_id}-#{span_data.hex_span_id}"
-        txname = @txn_manager.get(trace_span_id) || ''
-        event.addInfo('TransactionName', txname)
-        @txn_manager.del(trace_span_id)
-      end
-
-      ##
-      # report exception event
-      def report_exception_event(span_event)
-        event = @context.createEvent((span_event.timestamp.to_i / 1000).to_i)
-        event.addInfo('Label', 'error')
-        event.addInfo('Spec', 'error')
-
-        unless span_event.attributes.nil?
-          attributes = span_event.attributes.dup
-          attributes.delete('exception.type') if event.addInfo('ErrorClass', attributes['exception.type'])
-          attributes.delete('exception.message') if event.addInfo('ErrorMsg', attributes['exception.message'])
-          attributes.delete('exception.stacktrace') if event.addInfo('Backtrace', attributes['exception.stacktrace'])
-          attributes.each { |key, value| event.addInfo(key, value) }
-        end
-
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] exception event #{event.metadataString}" }
-        @reporter.send_report(event, with_system_timestamp: false)
-      end
-
-      ##
-      # report non-exception/info event
-      def report_info_event(span_event)
-        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}" }
-        @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
-        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
-    end
-  end
-end