solarwinds_apm 6.0.0.preV1 → 6.0.0.preV3

data/lib/solarwinds_apm/config.rb

@@ -11,13 +11,13 @@ module SolarWindsAPM
   module Config
     @@config = {}
     @@instrumentation = [:action_controller, :action_controller_api, :action_view,
-                        :active_record, :bunnyclient, :bunnyconsumer, :curb,
-                        :dalli, :delayed_jobclient, :delayed_jobworker,
-                        :excon, :faraday, :graphql, :grpc_client, :grpc_server, :grape,
-                        :httpclient, :nethttp, :memcached, :mongo, :moped, :padrino, :rack, :redis,
-                        :resqueclient, :resqueworker, :rest_client,
-                        :sequel, :sidekiqclient, :sidekiqworker, :sinatra, :typhoeus,
-                        :curb, :excon, :faraday, :httpclient, :nethttp, :rest_client, :typhoeus]
+                         :active_record, :bunnyclient, :bunnyconsumer, :curb,
+                         :dalli, :delayed_jobclient, :delayed_jobworker,
+                         :excon, :faraday, :graphql, :grpc_client, :grpc_server, :grape,
+                         :httpclient, :nethttp, :memcached, :mongo, :moped, :padrino, :rack, :redis,
+                         :resqueclient, :resqueworker, :rest_client,
+                         :sequel, :sidekiqclient, :sidekiqworker, :sinatra, :typhoeus,
+                         :curb, :excon, :faraday, :httpclient, :nethttp, :rest_client, :typhoeus]
 
     ##
     # load_config_file
@@ -47,28 +47,21 @@ module SolarWindsAPM
       config_file = File.join(Dir.pwd, 'solarwinds_apm_config.rb')
       config_files << config_file if File.exist?(config_file)
 
-      SolarWindsAPM.logger.warn {"[#{self.name}/#{__method__}] Multiple configuration files configured, using the first one listed: #{config_files.join(', ')}"} if config_files.size > 1
+      SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] Multiple configuration files configured, using the first one listed: #{config_files.join(', ')}"} if config_files.size > 1
       load(config_files[0]) if config_files.size > 0
 
       set_log_level        # sets SolarWindsAPM::Config[:debug_level], SolarWindsAPM.logger.level
-      set_verbose_level    # the verbose setting is only relevant for ruby, ENV['SW_APM_GEM_VERBOSE'] overrides
     end
 
     def self.config_from_env
-      config_files = []
       if File.exist?(ENV['SW_APM_CONFIG_RUBY']) && !File.directory?(ENV['SW_APM_CONFIG_RUBY'])
-        config_files << ENV['SW_APM_CONFIG_RUBY']
+        config_file = ENV['SW_APM_CONFIG_RUBY']
       elsif File.exist?(File.join(ENV['SW_APM_CONFIG_RUBY'], 'solarwinds_apm_config.rb'))
-        config_files << File.join(ENV['SW_APM_CONFIG_RUBY'], 'solarwinds_apm_config.rb')
+        config_file = File.join(ENV['SW_APM_CONFIG_RUBY'], 'solarwinds_apm_config.rb')
       else
-        SolarWindsAPM.logger.warn {"[#{self.name}/#{__method__}] Could not find the configuration file set by the SW_APM_CONFIG_RUBY environment variable:  #{ENV['SW_APM_CONFIG_RUBY']}"}
+        SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] Could not find the configuration file set by the SW_APM_CONFIG_RUBY environment variable:  #{ENV['SW_APM_CONFIG_RUBY']}"}
       end
-      config_files
-    end
-
-    def self.set_verbose_level
-      verbose = ENV.has_key?('SW_APM_GEM_VERBOSE')? ENV['SW_APM_GEM_VERBOSE'].downcase == 'true' : nil
-      SolarWindsAPM::Config[:verbose] = verbose
+      config_file
     end
 
     def self.set_log_level
@@ -86,9 +79,9 @@ module SolarWindsAPM
     # to create an output similar to the content of the config file
     #
     def self.print_config
-      SolarWindsAPM.logger.warn {"[#{self.name}/#{__method__}] General configurations list blow:"}
+      SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] General configurations list blow:"}
       @@config.each do |k,v|
-        SolarWindsAPM.logger.warn {"[#{self.name}/#{__method__}] Config Key/Value: #{k}, #{v.inspect}"}
+        SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] Config Key/Value: #{k}, #{v.inspect}"}
       end
     end
 
@@ -99,9 +92,6 @@ module SolarWindsAPM
     # The defaults are read from the template configuration file.
     #
     def self.initialize(_data={})
-      @@config[:profiling] = :disabled
-      @@config[:profiling_interval] = 5
-
       # for config file backward compatibility
       @@instrumentation.each {|inst| @@config[inst] = {}}
       @@config[:transaction_name] = {}
@@ -137,40 +127,24 @@ module SolarWindsAPM
 
       case key
       when :sampling_rate
-        SolarWindsAPM.logger.warn {"[#{self.name}/#{__method__}] sampling_rate is not a supported setting for SolarWindsAPM::Config. Please use :sample_rate."}
+        SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] sampling_rate is not a supported setting for SolarWindsAPM::Config. Please use :sample_rate."}
 
       when :sample_rate
         unless value.is_a?(Integer) || value.is_a?(Float)
-          SolarWindsAPM.logger.warn {"[#{self.name}/#{__method__}] :sample_rate must be a number between 0 and 1000000 (1m) (provided: #{value}), corrected to 0"}
+          SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] :sample_rate must be a number between 0 and 1000000 (1m) (provided: #{value}), corrected to 0"}
           value = 0
         end
 
         # Validate :sample_rate value
         unless value.between?(0, 1e6)
           new_value = value < 0 ? 0 : 1_000_000
-          SolarWindsAPM.logger.warn {"[#{self.name}/#{__method__}] :sample_rate must be between 0 and 1000000 (1m) (provided: #{value}), corrected to #{new_value}"}
+          SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] :sample_rate must be between 0 and 1000000 (1m) (provided: #{value}), corrected to #{new_value}"}
         end
 
         # Assure value is an integer
         @@config[key.to_sym] = new_value.to_i
         SolarWindsAPM.sample_rate(new_value) if SolarWindsAPM.loaded
 
-      when :profiling
-        SolarWindsAPM.logger.warn {"[#{self.name}/#{__method__}] Profiling feature is currently not available." }
-        @@config[:profiling] = :disabled
-
-      when  :profiling_interval
-        SolarWindsAPM.logger.warn {"[#{self.name}/#{__method__}] Profiling feature is currently not available. :profiling_interval setting is not configured."}
-        value = if value.is_a?(Integer) && value > 0
-                  [100, value].min
-                else
-                  10
-                end
-        @@config[:profiling_interval] = value
-        # CProfiler may not be loaded yet, the profiler will send the value
-        # after it is loaded
-        SolarWindsAPM::CProfiler.interval_setup(value) if defined? SolarWindsAPM::CProfiler
-
       when :transaction_settings
         compile_settings(value)
 
@@ -202,7 +176,7 @@ module SolarWindsAPM
 
       # `tracing: disabled` is the default
       disabled = settings.select { |v| !v.has_key?(:tracing) || v[:tracing] == :disabled }
-      enabled = settings.select { |v| v[:tracing] == :enabled }
+      enabled  = settings.select { |v| v[:tracing] == :enabled }
 
       SolarWindsAPM::Config[:enabled_regexps] = compile_regexp(enabled)
       SolarWindsAPM::Config[:disabled_regexps] = compile_regexp(disabled)
@@ -210,11 +184,8 @@ module SolarWindsAPM
     private_class_method :compile_settings
 
     def self.compile_regexp(settings)
-      regexp_regexp     = compile_settings_regexp(settings)
-      extensions_regexp = compile_settings_extensions(settings)
-
-      regexps = [regexp_regexp, extensions_regexp].flatten.compact
-
+      regexp_regexp = compile_settings_regexp(settings)
+      regexps       = [regexp_regexp].flatten.compact
       regexps.empty? ? nil : regexps
     end
     private_class_method :compile_regexp
@@ -230,7 +201,7 @@ module SolarWindsAPM
         begin
           v[:regexp].is_a?(String) ? Regexp.new(v[:regexp], v[:opts]) : Regexp.new(v[:regexp])
         rescue StandardError => e
-          SolarWindsAPM.logger.warn {"[#{self.name}/#{__method__}] Problem compiling transaction_settings item #{v}, will ignore. Error: #{e.message}"}
+          SolarWindsAPM.logger.warn {"[#{name}/#{__method__}] Problem compiling transaction_settings item #{v}, will ignore. Error: #{e.message}"}
           nil
         end
       end
@@ -239,19 +210,6 @@ module SolarWindsAPM
     end
     private_class_method :compile_settings_regexp
 
-    def self.compile_settings_extensions(value)
-      extensions = value.select do |v|
-        v.has_key?(:extensions) &&
-          v[:extensions].is_a?(Array) &&
-          !v[:extensions].empty?
-      end
-      extensions = extensions.map { |v| v[:extensions] }.flatten
-      extensions.keep_if { |v| v.is_a?(String) }
-
-      extensions.empty? ? nil : Regexp.new("(#{Regexp.union(extensions).source})(\\?.+){0,1}$")
-    end
-    private_class_method :compile_settings_extensions
-
     def self.reset_regexps
       SolarWindsAPM::Config[:enabled_regexps] = nil
       SolarWindsAPM::Config[:disabled_regexps] = nil

data/lib/solarwinds_apm/constants.rb

@@ -20,12 +20,10 @@ module SolarWindsAPM
     INTL_SWO_PROPAGATOR              = "solarwinds_propagator".freeze
     INTL_SWO_DEFAULT_PROPAGATORS     = [INTL_SWO_TRACECONTEXT_PROPAGATOR, "baggage",INTL_SWO_PROPAGATOR].freeze
     INTL_SWO_SUPPORT_EMAIL           = "SWO-support@solarwinds.com".freeze
-    INTL_SWO_CURRENT_SPAN_ID         = "sw-current-entry-span-id".freeze
-    INTL_SWO_CURRENT_TRACE_ID        = "sw-current-trace-id".freeze
-    INTL_SWO_CURRENT_TRACE_FLAG      = "sw-current-trace-flag".freeze
-
     INTL_SWO_OTEL_SCOPE_NAME         = "otel.scope.name".freeze
     INTL_SWO_OTEL_SCOPE_VERSION      = "otel.scope.version".freeze
+    INTL_SWO_OTEL_STATUS             = "otel.status".freeze
+    INTL_SWO_OTEL_STATUS_DESCRIPTION = "otel.status_description".freeze
 
     INTERNAL_TRIGGERED_TRACE         = "TriggeredTrace".freeze
   end

data/lib/solarwinds_apm/noop/context.rb

@@ -12,7 +12,7 @@ module SolarWindsAPM
     # toString would return the current trace context as string
     #
     def self.toString
-      '00-00000000000000000000000000000000-0000000000000000-00'
+      '99-00000000000000000000000000000000-0000000000000000-00'
     end
 
     ##

data/lib/solarwinds_apm/oboe_init_options.rb

@@ -1,6 +1,7 @@
 # Copyright (c) 2019 SolarWinds, LLC.
 # All rights reserved.
 require 'singleton'
+require 'uri'
 module SolarWindsAPM
   # OboeInitOptions
   class OboeInitOptions
@@ -96,9 +97,6 @@ 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
@@ -123,7 +121,7 @@ module SolarWindsAPM
       return '' unless @reporter == 'ssl'
 
       service_key = ENV['SW_APM_SERVICE_KEY'] || SolarWindsAPM::Config[:service_key]
-      unless service_key
+      if service_key.nil? || service_key == ''
         SolarWindsAPM.logger.error {"[#{self.class}/#{__method__}] SW_APM_SERVICE_KEY not configured."}
         return ''
       end
@@ -133,7 +131,7 @@ module SolarWindsAPM
       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."}
@@ -197,7 +195,7 @@ 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
       timeout.between?(0, 3000) ? timeout : 1000
     end
@@ -215,19 +213,16 @@ 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 = appoptics_collector?? "#{__dir__}/cert/star.appoptics.com.issuer.crt" : ENV['SW_APM_TRUSTEDPATH']
+      return String.new if file.nil? || file&.empty?
+
       begin
         certificate = File.open(file,"r").read
       rescue StandardError => e
         SolarWindsAPM.logger.error {"[#{self.class}/#{__method__}] certificates: #{file} doesn't exist or caused by #{e.message}."}
         certificate = String.new
       end
-      
+
       certificate
     end
 
@@ -236,7 +231,7 @@ module SolarWindsAPM
     end
 
     def appoptics_collector?
-      allowed_uri = ['collector.appoptics.com', 'collector-stg.appoptics.com', 
+      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
@@ -246,12 +241,12 @@ module SolarWindsAPM
       return uri if uri.nil? || uri.empty?
 
       begin
-        sanitized_uri = URI("http://#{uri}").host
+        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

@@ -19,12 +19,13 @@ module SolarWindsAPM
 
       def export(span_data, _timeout: nil)
         return FAILURE if @shutdown
-        
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] span_data: #{span_data}"}
+
+        status = SUCCESS
         span_data.each do |data|
-          log_span_data(data)
+          status = log_span_data(data)
         end
-        SUCCESS
+
+        status
       end
 
       def force_flush(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
@@ -39,64 +40,63 @@ module SolarWindsAPM
       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 
+          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."}
+        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
 
-        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)
+        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?
 
-          # 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
+        @reporter.send_report(event, with_system_timestamp: false)
 
-          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
+        # 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
 
-      def add_info_instrumentation_scope(event, span_data)
+      ##
+      # 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 # remove url parameters
+        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
@@ -104,14 +104,13 @@ module SolarWindsAPM
           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_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}"}
+      ##
+      # 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"
@@ -121,9 +120,12 @@ module SolarWindsAPM
         
         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?
       end
 
+      ##
+      # helper function that extract gem library version for func add_instrumented_framework
       def check_framework_version(framework)
         framework_version = nil
         if @version_cache.keys.include? framework
@@ -142,10 +144,12 @@ module SolarWindsAPM
             @version_cache[framework] = framework_version
           end
         end
-        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Current framework version cached: #{@version_cache.inspect}"}
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] current framework version cached: #{@version_cache.inspect}"}
         framework_version
       end
 
+      ##
+      # helper function that convert opentelemetry instrumentation name to gem library understandable
       def normalize_framework_name(framework)
         case framework
         when "net::http"
@@ -156,47 +160,48 @@ module SolarWindsAPM
         normalized
       end
 
+      ##
       # Add transaction name from cache to root span then removes from cache
-      def add_info_transaction_name(span_data, evt)
+      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}"
-        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)
+        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)
-        evt = @context.createEvent((span_event.timestamp.to_i / 1000).to_i)
-        evt.addInfo('Label', 'error')
-        evt.addInfo('Spec', 'error')
+        event = @context.createEvent((span_event.timestamp.to_i / 1000).to_i)
+        event.addInfo('Label', 'error')
+        event.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
+          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 #{evt.metadataString}"}
-        @reporter.send_report(evt, with_system_timestamp: false)
+
+        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)
-        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)
+        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
-        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}"
+        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