solarwinds_apm 6.0.0.prev6 → 6.0.1

data/lib/solarwinds_apm/noop.rb

@@ -0,0 +1,33 @@
+# 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_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/oboe_init_options.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
@@ -7,14 +9,18 @@
 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 # exposing these mainly for testing
+    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)
@@ -80,18 +86,18 @@ module SolarWindsAPM
         @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
+        @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
       ]
     end
 
@@ -102,104 +108,24 @@ module SolarWindsAPM
     private
 
     def reporter_and_host
-
       reporter = ENV['SW_APM_REPORTER'] || 'ssl'
 
-      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
-        # ____ SolarWindsAPM::Config[:reporter_host] and
-        # ____ SolarWindsAPM::Config[:reporter_port] were moved here from
-        # ____ oboe_metal.rb and are not documented anywhere
-        # ____ udp is for internal use only
-      when 'null'
-        host = ''
-      end
+      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
-      return '' unless @reporter == 'ssl'
-
-      service_key = ENV['SW_APM_SERVICE_KEY'] || SolarWindsAPM::Config[:service_key]
-      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})(.*)/)
-      token = match[1]
-      service_name = match[3]
-
-      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('=')
-        if key == 'service.name'
-          otel_resource_service_name = value
-          break
-        end
-      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)
-
-      "#{token}:#{service_name}"
-    end
-
-    # In case of java-collector, please provide a dummy service key
-    def validate_token(token)
-      unless /^[0-9a-zA-Z_-]{71}$/.match?(token)
-        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
-
-      true
-    end
-
-    def validate_transform_service_name(service_name)
-      if service_name.empty?
-        SolarWindsAPM.logger.error {"[#{self.class}/#{__method__}] SW_APM_SERVICE_KEY problem. Service Name is missing"}
-        return false
-      end
-
-      name_ = service_name.dup
-      name_.downcase!
-      name_.gsub!(/[^a-z0-9.:_-]/, '')
-      name_ = name_[0..254]
-
-      if name_ != service_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
-      true
+      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
@@ -214,8 +140,8 @@ module SolarWindsAPM
       proxy = ENV['SW_APM_PROXY'] || SolarWindsAPM::Config[:http_proxy] || ''
       return proxy if proxy == ''
 
-      unless /http:\/\/.*:\d+$/.match?(proxy)
-        SolarWindsAPM.logger.error {"[#{self.class}/#{__method__}] SW_APM_PROXY/http_proxy doesn't start with 'http://', #{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
 
@@ -225,13 +151,15 @@ module SolarWindsAPM
     def read_certificates
       certificate = ''
 
-      file = appoptics_collector?? "#{__dir__}/cert/star.appoptics.com.issuer.crt" : ENV['SW_APM_TRUSTEDPATH']
+      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.open(file,"r").read
+        certificate = File.read(file)
       rescue StandardError => e
-        SolarWindsAPM.logger.error {"[#{self.class}/#{__method__}] certificates: #{file} doesn't exist or caused by #{e.message}."}
+        SolarWindsAPM.logger.error do
+          "[#{self.class}/#{__method__}] certificates: #{file} doesn't exist or caused by #{e.message}."
+        end
       end
 
       certificate
@@ -245,7 +173,7 @@ module SolarWindsAPM
       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
+      (allowed_uri.include? ENV.fetch('SW_APM_COLLECTOR', nil))
     end
 
     def sanitize_collector_uri(uri)
@@ -255,9 +183,11 @@ module SolarWindsAPM
         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}"}
+        SolarWindsAPM.logger.error do
+          "[#{self.class}/#{__method__}] uri for collector #{uri} is malformat. Error: #{e.message}"
+        end
       end
-      ""
+      ''
     end
 
     def determine_oboe_log_type
@@ -266,5 +196,14 @@ module SolarWindsAPM
       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
   end
 end

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