solarwinds_apm 6.1.2 → 7.0.0.prev2

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

data/lib/solarwinds_apm/opentelemetry/solarwinds_processor.rb

@@ -1,174 +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
-    # reference: OpenTelemetry::SDK::Trace::SpanProcessor
-    class SolarWindsProcessor
-      HTTP_METHOD      = 'http.method'
-      HTTP_ROUTE       = 'http.route'
-      HTTP_STATUS_CODE = 'http.status_code'
-      HTTP_URL         = 'http.url'
-      LIBOBOE_HTTP_SPAN_STATUS_UNAVAILABLE = 0
-
-      attr_reader :txn_manager
-
-      def initialize(txn_manager)
-        @txn_manager = txn_manager
-      end
-
-      # Called when a {Span} is started, if the {Span#recording?}
-      # returns true.
-      #
-      # @param [Span] span the {Span} that just started.
-      # @param [Context] parent_context the parent {Context} of the newly
-      #  started span.
-      def on_start(span, parent_context)
-        SolarWindsAPM.logger.debug do
-          "[#{self.class}/#{__method__}] processor on_start span: #{span.to_span_data.inspect}, parent_context: #{parent_context.inspect}"
-        end
-
-        return if non_entry_span(parent_context: parent_context)
-
-        trace_flags = span.context.trace_flags.sampled? ? '01' : '00'
-        @txn_manager.set_root_context_h(span.context.hex_trace_id, "#{span.context.hex_span_id}-#{trace_flags}")
-        span.add_attributes({ 'sw.is_entry_span' => true })
-      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?}
-      # returns true.
-      #
-      # @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 non_entry_span(span: span)
-
-        span_time  = calculate_span_time(start_time: span.start_timestamp, end_time: span.end_timestamp)
-        domain     = nil
-        has_error  = error?(span)
-        trans_name = calculate_transaction_names(span)
-        if span_http?(span)
-          status_code    = get_http_status_code(span)
-          request_method = span.attributes[HTTP_METHOD]
-          url_tran       = span.attributes[HTTP_URL]
-
-          SolarWindsAPM.logger.debug do
-            "[#{self.class}/#{__method__}] createHttpSpan with\n
-                                          trans_name: #{trans_name}\n
-                                          url_tran: #{url_tran}\n
-                                          domain: #{domain}\n
-                                          span_time: #{span_time}\n
-                                          status_code: #{status_code}\n
-                                          request_method: #{request_method}\n
-                                          has_error: #{has_error}"
-          end
-
-          liboboe_txn_name = SolarWindsAPM::Span.createHttpSpan(trans_name, url_tran, domain, span_time, status_code,
-                                                                request_method, has_error)
-
-        else
-
-          SolarWindsAPM.logger.debug do
-            "[#{self.class}/#{__method__}] createSpan with \n
-                                          trans_name: #{trans_name}\n
-                                          domain: #{domain}\n
-                                          span_time: #{span_time}\n
-                                          has_error: #{has_error}"
-          end
-
-          liboboe_txn_name = SolarWindsAPM::Span.createSpan(trans_name, domain, span_time, has_error)
-        end
-
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] liboboe_txn_name: #{liboboe_txn_name}" }
-        if span.context.trace_flags.sampled?
-          @txn_manager["#{span.context.hex_trace_id}-#{span.context.hex_span_id}"] =
-            liboboe_txn_name
-        end
-        @txn_manager.delete_root_context_h(span.context.hex_trace_id)
-      rescue StandardError => e
-        SolarWindsAPM.logger.info do
-          "[#{self.class}/#{__method__}] solarwinds_processor on_finish error: #{e.message}"
-        end
-      end
-
-      # @param [optional Numeric] timeout An optional timeout in seconds.
-      # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
-      #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
-      def force_flush(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
-        ::OpenTelemetry::SDK::Trace::Export::SUCCESS
-      end
-
-      # @param [optional Numeric] timeout An optional timeout in seconds.
-      # @return [Integer] Export::SUCCESS if no error occurred, Export::FAILURE if
-      #   a non-specific failure occurred, Export::TIMEOUT if a timeout occurred.
-      def shutdown(timeout: nil) # rubocop:disable Lint/UnusedMethodArgument
-        ::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)
-        span.kind == ::OpenTelemetry::Trace::SpanKind::SERVER && !span.attributes[HTTP_METHOD].nil?
-      end
-
-      # Calculate if this span instance has_error
-      # return [Integer]
-      def error?(span)
-        span.status.code == ::OpenTelemetry::Trace::Status::ERROR ? 1 : 0
-      end
-
-      # Calculate HTTP status_code from span or default to UNAVAILABLE
-      # Something went wrong in OTel or instrumented service crashed early
-      # if no status_code in attributes of HTTP span
-      def get_http_status_code(span)
-        span.attributes[HTTP_STATUS_CODE] || LIBOBOE_HTTP_SPAN_STATUS_UNAVAILABLE
-      end
-
-      # check if it's entry span based on no parent or parent is remote
-      def non_entry_span(span: nil, parent_context: nil)
-        if parent_context
-          parent_span = ::OpenTelemetry::Trace.current_span(parent_context)
-          parent_span && parent_span.context != ::OpenTelemetry::Trace::SpanContext::INVALID && parent_span.context.remote? == false
-        elsif span
-          span.attributes['sw.is_entry_span'] != true
-        end
-      end
-
-      # Get trans_name and url_tran of this span instance.
-      # Predecessor order: custom SDK > env var SW_APM_TRANSACTION_NAME > automatic naming
-      def calculate_transaction_names(span)
-        trace_span_id = "#{span.context.hex_trace_id}-#{span.context.hex_span_id}"
-        trans_name = @txn_manager.get(trace_span_id)
-        if trans_name
-          SolarWindsAPM.logger.debug do
-            "[#{self.class}/#{__method__}] found trans name from txn_manager: #{trans_name} by #{trace_span_id}"
-          end
-          @txn_manager.del(trace_span_id)
-        elsif ENV.key?('SW_APM_TRANSACTION_NAME') && ENV['SW_APM_TRANSACTION_NAME'] != ''
-          trans_name = ENV.fetch('SW_APM_TRANSACTION_NAME', nil)
-        else
-          trans_name = span.attributes[HTTP_ROUTE] || nil
-          trans_name = span.name if span.name && (trans_name.nil? || trans_name.empty?)
-        end
-        trans_name
-      end
-
-      # Calculate span time in microseconds (us) using start and end time
-      # in nanoseconds (ns). OTel span start/end_time are optional.
-      def calculate_span_time(start_time: nil, end_time: nil)
-        return 0 if start_time.nil? || end_time.nil?
-
-        ((end_time.to_i - start_time.to_i) / 1e3).round
-      end
-    end
-  end
-end