solarwinds_apm 6.0.0.preV1 → 6.0.0.preV3

data/lib/solarwinds_apm/opentelemetry/solarwinds_processor.rb

@@ -32,11 +32,9 @@ module SolarWindsAPM
         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}"}
+        @txn_manager.set_root_context_h(span.context.hex_trace_id,"#{span.context.hex_span_id}-#{trace_flags}")
+      rescue StandardError => e
+        SolarWindsAPM.logger.info {"[#{self.class}/#{__method__}] processor on_start error: #{e.message}"}
       end
 
       # Called when a {Span} is ended, if the {Span#recording?}
@@ -47,7 +45,9 @@ module SolarWindsAPM
       # Only calculate inbound metrics for service root spans
       #
       # @param [Span] span the {Span} that just ended.
-      def on_finish(span) 
+      def on_finish(span)
+        SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] processor on_finish span: #{span.inspect}"}
+
         if span.parent_span_id != ::OpenTelemetry::Trace::INVALID_SPAN_ID 
           @exporter&.export([span.to_span_data]) if span.context.trace_flags.sampled?
           return
@@ -57,40 +57,44 @@ module SolarWindsAPM
         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)
+          status_code    = get_http_status_code(span)
           request_method = span.attributes[HTTP_METHOD]
+          url_tran       = span.attributes[HTTP_URL]
 
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] createHttpSpan with\n
+          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}"}
+                                          has_error: #{has_error}"
+          end
 
-          liboboe_txn_name = SolarWindsAPM::Span.createHttpSpan(trans_name,url_tran,domain,span_time,status_code,
-                                                                    request_method,has_error)
+          liboboe_txn_name = SolarWindsAPM::Span.createHttpSpan(trans_name,url_tran,domain,span_time,status_code,request_method,has_error)
   
         else
           
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] createSpan with \n
+          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}"}
+                                          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?
-
+        @txn_manager.delete_root_context_h(span.context.hex_trace_id)
         @exporter&.export([span.to_span_data]) if span.context.trace_flags.sampled?
+      rescue StandardError => e
+        SolarWindsAPM.logger.info {"[#{self.class}/#{__method__}] can't flush span to exporter; processor on_finish error: #{e.message}"}
+        ::OpenTelemetry::SDK::Trace::Export::FAILURE
       end
 
       # Export all ended spans to the configured `Exporter` that have not yet
@@ -105,7 +109,7 @@ module SolarWindsAPM
       # @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
+        @exporter&.force_flush(timeout: timeout) || ::OpenTelemetry::SDK::Trace::Export::SUCCESS
       end
 
       # Called when {TracerProvider#shutdown} is called.
@@ -114,14 +118,13 @@ module SolarWindsAPM
       # @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
+        @exporter&.shutdown(timeout: timeout) || ::OpenTelemetry::SDK::Trace::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
 
@@ -140,10 +143,11 @@ module SolarWindsAPM
 
       # 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)
+        trans_name = @txn_manager.get(trace_span_id)
+        if trans_name
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] found trans name from txn_manager: #{trans_name} by #{trace_span_id}"}
+          @txn_manager.del(trace_span_id)
         else
           trans_name = span.attributes[HTTP_ROUTE] || nil
           trans_name = span.name if span.name && (trans_name.nil? || trans_name.empty?)

data/lib/solarwinds_apm/opentelemetry/solarwinds_propagator.rb

@@ -2,6 +2,7 @@ module SolarWindsAPM
   module OpenTelemetry
     module SolarWindsPropagator
       # TextMapPropagator
+      # propagator error will be rescued by OpenTelemetry::Context::Propagation::TextMapPropagator
       class TextMapPropagator
         TRACESTATE_HEADER_NAME    = "tracestate".freeze
         XTRACEOPTIONS_HEADER_NAME = "x-trace-options".freeze
@@ -26,19 +27,11 @@ module SolarWindsAPM
         #   if extraction fails
         def extract(carrier, context: ::OpenTelemetry::Context.current, getter: ::OpenTelemetry::Context::Propagation.text_map_getter)
 
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] context(before): #{context.inspect} #{context.nil?}"}
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] extract context: #{context.inspect}"}
 
-          context = ::OpenTelemetry::Context.new({}) if context.nil?
-
-          xtraceoptions_header = getter.get(carrier, XTRACEOPTIONS_HEADER_NAME)
-          context = context.set_value(INTL_SWO_X_OPTIONS_KEY, xtraceoptions_header) if xtraceoptions_header
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] xtraceoptions_header: #{xtraceoptions_header}"}
-
-          signature_header = getter.get(carrier, XTRACEOPTIONS_SIGNATURE_HEADER_NAME)
-          context = context.set_value(INTL_SWO_SIGNATURE_KEY, signature_header) if signature_header
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] signature_header: #{signature_header}; propagator extract context: #{context.inspect}"}
-
-          context
+          context = context.nil?? ::OpenTelemetry::Context.new({}) : context
+          context = inject_extracted_header(carrier, context, getter, XTRACEOPTIONS_HEADER_NAME, INTL_SWO_X_OPTIONS_KEY)
+          inject_extracted_header(carrier, context, getter, XTRACEOPTIONS_SIGNATURE_HEADER_NAME, INTL_SWO_SIGNATURE_KEY)
         end
 
         # Inject trace context into the supplied carrier.
@@ -51,32 +44,30 @@ module SolarWindsAPM
         def inject(carrier, context: ::OpenTelemetry::Context.current, setter: ::OpenTelemetry::Context::Propagation.text_map_setter)
 
           SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] inject context: #{context.inspect}"}
-          
-          cspan = ::OpenTelemetry::Trace.current_span(context)
-          span_context = cspan&.context
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] cspan #{cspan.inspect}; span_context #{span_context.inspect}"}
+        
+          span_context = ::OpenTelemetry::Trace.current_span(context)&.context
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] span_context #{span_context.inspect}"}
           return unless span_context&.valid?
 
-          sw_value = Transformer.sw_from_context(span_context)  # sw_value is a string
+          trace_flag = span_context.trace_flags.sampled?? 1 : 0
+          sw_value   = "#{span_context.hex_span_id}-0#{trace_flag}"
           trace_state_header = carrier[TRACESTATE_HEADER_NAME].nil?? nil : carrier[TRACESTATE_HEADER_NAME]
-
           SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] sw_value: #{sw_value}; trace_state_header: #{trace_state_header}"}
 
-          # Prepare carrier with carrier's or new tracestate
-          trace_state = nil
+          # prepare carrier with carrier's or new tracestate
           if trace_state_header.nil?
-            # Only create new trace state if valid span_id
-            return if span_context.span_id == ::OpenTelemetry::Trace::INVALID_SPAN_ID
-              
-            trace_state = ::OpenTelemetry::Trace::Tracestate.create({SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY => sw_value})
-            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] creating new trace state: #{trace_state.inspect}"}
+            # only create new trace state if valid span_id
+            unless span_context.span_id == ::OpenTelemetry::Trace::INVALID_SPAN_ID
+              trace_state = ::OpenTelemetry::Trace::Tracestate.create({SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY => sw_value})
+              SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] creating new trace state: #{trace_state.inspect}"}
+              setter.set(carrier, TRACESTATE_HEADER_NAME, Utils.trace_state_header(trace_state))
+            end
           else
             trace_state_from_string = ::OpenTelemetry::Trace::Tracestate.from_string(trace_state_header)
             trace_state = trace_state_from_string.set_value(SolarWindsAPM::Constants::INTL_SWO_TRACESTATE_KEY, sw_value)
-            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] Updating/Adding trace state for injection #{trace_state.inspect}"}
+            SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] updating/adding trace state for injection #{trace_state.inspect}"}
+            setter.set(carrier, TRACESTATE_HEADER_NAME, Utils.trace_state_header(trace_state))
           end
-
-          setter.set(carrier, TRACESTATE_HEADER_NAME, Transformer.trace_state_header(trace_state))
         end
 
         # Returns the predefined propagation fields. If your carrier is reused, you
@@ -86,6 +77,15 @@ module SolarWindsAPM
         def fields
           TRACESTATE_HEADER_NAME
         end
+
+        private
+        
+        def inject_extracted_header(carrier, context, getter, header, inject_key)
+          extracted_header = getter.get(carrier, header)
+          context = context.set_value(inject_key, extracted_header) if extracted_header
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] #{header}: #{inject_key} = #{extracted_header}"}
+          context
+        end
       end
     end
   end

data/lib/solarwinds_apm/opentelemetry/solarwinds_response_propagator.rb

@@ -2,6 +2,7 @@ module SolarWindsAPM
   module OpenTelemetry
     module SolarWindsResponsePropagator
       # ResponsePropagator
+      # response propagator error will be rescued by OpenTelemetry::Instrumentation::Rack::Middlewares::EventHandler
       class TextMapPropagator
         HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS = "Access-Control-Expose-Headers".freeze
         XTRACE_HEADER_NAME                        = "x-trace".freeze
@@ -25,26 +26,20 @@ module SolarWindsAPM
         #   text map setter will be used.
         def inject(carrier, context: ::OpenTelemetry::Context.current, setter: ::OpenTelemetry::Context::Propagation.text_map_setter)
 
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] response propagator context: #{context.inspect}"}
           span_context = ::OpenTelemetry::Trace.current_span(context).context
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] response propagator span_context: #{span_context.inspect}"}
-          return unless span_context.valid?
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] context: #{context.inspect}; span_context: #{span_context.inspect}"}
+          return unless span_context&.valid?
           
-          x_trace = Transformer.traceparent_from_context(span_context)
-          setter.set(carrier, XTRACE_HEADER_NAME, x_trace)
-          exposed_headers = [XTRACE_HEADER_NAME]
-
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] response propagator span_context.tracestate: #{span_context.tracestate.inspect}"}
+          x_trace                = Utils.traceparent_from_context(span_context)
+          exposed_headers        = [XTRACE_HEADER_NAME]
           xtraceoptions_response = recover_response_from_tracestate(span_context.tracestate)
 
-          unless xtraceoptions_response.empty?
-            exposed_headers << XTRACEOPTIONS_RESPONSE_HEADER_NAME
-            setter.set(carrier, XTRACEOPTIONS_RESPONSE_HEADER_NAME, xtraceoptions_response)
-          end
+          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] x-trace: #{x_trace}; exposed headers: #{exposed_headers.inspect}; x-trace-options-response: #{xtraceoptions_response}"}
+          exposed_headers.append(XTRACEOPTIONS_RESPONSE_HEADER_NAME) unless xtraceoptions_response.empty?
 
-          SolarWindsAPM.logger.debug {"[#{self.class}/#{__method__}] response propagator exposed_headers: #{exposed_headers.inspect}"}
+          setter.set(carrier, XTRACE_HEADER_NAME, x_trace)
+          setter.set(carrier, XTRACEOPTIONS_RESPONSE_HEADER_NAME, xtraceoptions_response) unless xtraceoptions_response.empty?
           setter.set(carrier, HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS, exposed_headers.join(","))
-
         end
 
         # Returns the predefined propagation fields. If your carrier is reused, you