solarwinds_apm 6.1.1 → 7.0.0.prev1

data/lib/solarwinds_apm/opentelemetry/otlp_processor.rb

@@ -8,41 +8,60 @@
 
 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
+    # reference: OpenTelemetry::SDK::Trace::SpanProcessor
+    class OTLPProcessor
+      attr_reader :txn_manager
+
+      SW_TRANSACTION_NAME = 'sw.transaction'
+      SW_IS_ENTRY_SPAN    = 'sw.is_entry_span'
+      SW_IS_ERROR         = 'sw.is_error'
+
+      HTTP_METHOD         = 'http.method'
+      HTTP_ROUTE          = 'http.route'
+      HTTP_STATUS_CODE    = 'http.status_code'
+      HTTP_URL            = 'http.url'
+
+      INVALID_HTTP_STATUS_CODE = 0
+
+      def initialize(txn_manager)
+        @txn_manager = txn_manager
+        @meters      = { 'sw.apm.request.metrics' => ::OpenTelemetry.meter_provider.meter('sw.apm.request.metrics') }
+        @metrics     = { response_time: @meters['sw.apm.request.metrics'].create_histogram('trace.service.response_time', unit: 'ms', description: 'Duration of each entry span for the service, typically meaning the time taken to process an inbound request.') }
+        @transaction_name = nil
       end
 
-      # @param [Span] span the {Span} that just started.
-      # @param [Context] parent_context the
-      #  started span.
+      # @param [Span] span the (mutable) {Span} that just started.
+      # @param [Context] parent_context of the started span.
       def on_start(span, parent_context)
         SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] processor on_start span: #{span.to_span_data.inspect}" }
 
         return if non_entry_span(parent_context: parent_context)
 
-        span.add_attributes(span_attributes(span))
-        span.add_attributes({ 'sw.is_entry_span' => true })
+        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
 
-      # @param [Span] span the {Span} that just ended.
+      def on_finishing(span)
+        @transaction_name = calculate_transaction_names(span)
+        span.set_attribute(SW_TRANSACTION_NAME, @transaction_name)
+        @txn_manager.delete_root_context_h(span.context.hex_trace_id)
+      end
+
+      # @param [Span] span the (immutable) {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)
+        # pull should work on any instrument from oboe_sampler
+        ::OpenTelemetry.meter_provider.metric_readers.each do |reader|
+          reader.pull if reader.respond_to? :pull
+        end
+
         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}" }
@@ -50,24 +69,10 @@ module SolarWindsAPM
 
       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)
+          SW_IS_ERROR => error?(span) == 1,
+          SW_TRANSACTION_NAME => @transaction_name
         }
 
         if span_http?(span)
@@ -76,26 +81,33 @@ module SolarWindsAPM
           meter_attrs['http.method'] = span.attributes[HTTP_METHOD] if span.attributes[HTTP_METHOD]
         end
         SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] meter_attrs: #{meter_attrs.inspect}" }
+        meter_attrs.compact!
         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)
+      def calculate_lambda_transaction_name(span_name)
+        (ENV['SW_APM_TRANSACTION_NAME'] || ENV['AWS_LAMBDA_FUNCTION_NAME'] || span_name || 'unknown').slice(0, SolarWindsAPM::Constants::MAX_TXN_NAME_LENGTH)
       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
+      # 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)
+        return calculate_lambda_transaction_name(span.name) if SolarWindsAPM::Utils.determine_lambda
+
+        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['SW_APM_TRANSACTION_NAME'].to_s.empty?
+          trans_name = ENV.fetch('SW_APM_TRANSACTION_NAME', nil)
+        else
+          trans_name = span.attributes[HTTP_ROUTE] || nil
+          trans_name = span.name if trans_name.to_s.empty? && span.name
+        end
+        trans_name.to_s.slice(0, SolarWindsAPM::Constants::MAX_TXN_NAME_LENGTH)
       end
 
       def record_request_metrics(span)
@@ -106,31 +118,40 @@ module SolarWindsAPM
         @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)
+      # 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?
 
-        _, sample_count = SolarWindsAPM.oboe_api.consumeSampleCount
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] sample_count: #{sample_count}" }
-        @metrics[:samplecount].add(sample_count)
+        ((end_time.to_i - start_time.to_i) / 1e3).round
+      end
 
-        _, request_count = SolarWindsAPM.oboe_api.consumeRequestCount
-        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] request_count: #{request_count}" }
-        @metrics[:request_count].add(request_count)
+      # Calculate if this span instance has_error
+      # return [Integer]
+      def error?(span)
+        span.status.code == ::OpenTelemetry::Trace::Status::ERROR ? 1 : 0
+      end
 
-        _, 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)
+      # 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
 
-        _, 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)
+      # 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] || INVALID_HTTP_STATUS_CODE
+      end
 
-        _, 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)
+      # 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
     end
   end

data/lib/solarwinds_apm/opentelemetry/solarwinds_propagator.rb

@@ -51,8 +51,6 @@ 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__}] inject context: #{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?

data/lib/solarwinds_apm/opentelemetry/solarwinds_response_propagator.rb

@@ -16,6 +16,7 @@ module SolarWindsAPM
         XTRACE_HEADER_NAME                        = 'x-trace'
         XTRACEOPTIONS_RESPONSE_HEADER_NAME        = 'x-trace-options-response'
         INTL_SWO_EQUALS                           = '='
+        SW_XTRACEOPTIONS_RESPONSE_KEY             = 'xtrace_options_response'
 
         private_constant \
           :HTTP_HEADER_ACCESS_CONTROL_EXPOSE_HEADERS, :XTRACE_HEADER_NAME,
@@ -36,14 +37,13 @@ module SolarWindsAPM
                    setter: ::OpenTelemetry::Context::Propagation.text_map_setter)
           span_context = ::OpenTelemetry::Trace.current_span(context).context
 
-          SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] context current_span: #{context.instance_variable_get(:@entries)&.values&.first.inspect}" }
           SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] span_context: #{span_context.inspect}" }
 
           return unless span_context&.valid?
 
           x_trace                = Utils.traceparent_from_context(span_context)
           exposed_headers        = [XTRACE_HEADER_NAME]
-          xtraceoptions_response = recover_response_from_tracestate(span_context.tracestate)
+          xtraceoptions_response = recover_response_from_tracestate(span_context)
 
           SolarWindsAPM.logger.debug do
             "[#{self.class}/#{__method__}] x-trace: #{x_trace}; exposed headers: #{exposed_headers.inspect}; x-trace-options-response: #{xtraceoptions_response}"
@@ -69,11 +69,12 @@ module SolarWindsAPM
         private
 
         # sw_xtraceoptions_response_key -> xtrace_options_response
-        def recover_response_from_tracestate(tracestate)
-          sanitized = tracestate.value(XTraceOptions.sw_xtraceoptions_response_key)
+        def recover_response_from_tracestate(span_context)
+          sanitized = span_context.tracestate.value(SW_XTRACEOPTIONS_RESPONSE_KEY)
           sanitized = '' if sanitized.nil?
           sanitized = sanitized.gsub(SolarWindsAPM::Constants::INTL_SWO_EQUALS_W3C_SANITIZED,
                                      SolarWindsAPM::Constants::INTL_SWO_EQUALS)
+          sanitized = sanitized.gsub(':', SolarWindsAPM::Constants::INTL_SWO_EQUALS)
           sanitized = sanitized.gsub(SolarWindsAPM::Constants::INTL_SWO_COMMA_W3C_SANITIZED,
                                      SolarWindsAPM::Constants::INTL_SWO_COMMA)
           SolarWindsAPM.logger.debug do

data/lib/solarwinds_apm/opentelemetry.rb

@@ -6,14 +6,12 @@
 #
 # 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 'opentelemetry/sdk'
-require 'opentelemetry/instrumentation/all'
-
-# TODO: in future, it should add opentelemetry-metrics-sdk and require it here
+require 'opentelemetry-sdk'
+require 'opentelemetry-metrics-sdk'
+require 'opentelemetry-exporter-otlp'
+require 'opentelemetry-exporter-otlp-metrics'
+require 'opentelemetry-instrumentation-all'
 
 require_relative 'opentelemetry/solarwinds_propagator'
-require_relative 'opentelemetry/solarwinds_processor'
-require_relative 'opentelemetry/solarwinds_sampler'
-require_relative 'opentelemetry/solarwinds_exporter'
 require_relative 'opentelemetry/solarwinds_response_propagator'
 require_relative 'opentelemetry/otlp_processor'

data/lib/solarwinds_apm/otel_native_config.rb

@@ -0,0 +1,177 @@
+# 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 'api'
+require_relative 'support'
+require_relative 'opentelemetry'
+require_relative 'sampling'
+
+module SolarWindsAPM
+  # OTelNativeConfig module
+  module OTelNativeConfig
+    @@config           = {}
+    @@config_map       = {}
+    @@agent_enabled    = false
+
+    RESOURCE_ATTRIBUTES = 'RESOURCE_ATTRIBUTES'
+
+    def self.initialize
+      return unless defined?(::OpenTelemetry::SDK::Configurator)
+
+      is_lambda = SolarWindsAPM::Utils.determine_lambda
+
+      ENV['OTEL_TRACES_EXPORTER'] = ENV['OTEL_TRACES_EXPORTER'].to_s.split(',').tap { |e| e << 'otlp' unless e.include?('otlp') }.join(',')
+
+      # add response propagator to rack instrumentation
+      resolve_response_propagator
+
+      # dbo: traceparent injection as sql comments
+      require_relative 'patch/tag_sql_patch' if SolarWindsAPM::Config[:tag_sql]
+
+      # endpoint and service_key for non-lambda
+      otlp_endpoint = nil
+      unless is_lambda
+        otlp_endpoint = SolarWindsAPM::OTLPEndPoint.new
+        otlp_endpoint.config_otlp_token_and_endpoint
+        return if otlp_endpoint.token.nil?
+      end
+
+      ENV['OTEL_RESOURCE_ATTRIBUTES'] = "sw.apm.version=#{SolarWindsAPM::Version::STRING},sw.data.module=apm,service.name=#{ENV.fetch('OTEL_SERVICE_NAME', nil)}," + ENV['OTEL_RESOURCE_ATTRIBUTES'].to_s
+
+      # resource attributes
+      mandatory_resource = SolarWindsAPM::ResourceDetector.detect
+      additional_attributes = @@config_map[RESOURCE_ATTRIBUTES]
+      if additional_attributes
+        if additional_attributes.instance_of?(::OpenTelemetry::SDK::Resources::Resource)
+          final_attributes = mandatory_resource.merge(additional_attributes)
+        elsif additional_attributes.instance_of?(Hash)
+          final_attributes = mandatory_resource.merge(::OpenTelemetry::SDK::Resources::Resource.create(additional_attributes))
+        end
+        @@config_map.delete(RESOURCE_ATTRIBUTES)
+      else
+        final_attributes = mandatory_resource.merge({})
+      end
+
+      # set gzip compression
+      %w[TRACES METRICS LOGS].each do |signal|
+        ENV["OTEL_EXPORTER_OTLP_#{signal}_COMPRESSION"] = 'gzip' if ENV["OTEL_EXPORTER_OTLP_#{signal}_COMPRESSION"].to_s.empty? && ENV['OTEL_EXPORTER_OTLP_COMPRESSION'].to_s.empty?
+      end
+
+      # set delta temporality
+      ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'] = 'delta' if ENV['OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE'].to_s.empty?
+
+      # log level
+      if ENV['OTEL_LOG_LEVEL'].to_s.empty?
+        log_level = (ENV['SW_APM_DEBUG_LEVEL'] || SolarWindsAPM::Config[:debug_level] || 3).to_i
+        ENV['OTEL_LOG_LEVEL'] = SolarWindsAPM::Config::SW_LOG_LEVEL_MAPPING.dig(log_level, :otel)
+      end
+
+      ::OpenTelemetry::SDK.configure do |c|
+        c.resource = final_attributes
+        c.use_all(@@config_map)
+      end
+
+      # append our propagators
+      ::OpenTelemetry.propagation.instance_variable_get(:@propagators).append(SolarWindsAPM::OpenTelemetry::SolarWindsPropagator::TextMapPropagator.new)
+
+      # add sw metrics processors (only record respone_time)
+      txn_manager = TxnNameManager.new
+      otlp_processor = SolarWindsAPM::OpenTelemetry::OTLPProcessor.new(txn_manager)
+
+      @@config[:metrics_processor] = otlp_processor
+      ::OpenTelemetry.tracer_provider.add_span_processor(otlp_processor)
+
+      # collector, service and headers are used for http sampler get settings
+      sampler_config = {
+        tracing_mode: SolarWindsAPM::Config[:tracing_mode],
+        trigger_trace_enabled: SolarWindsAPM::Config[:trigger_tracing_mode],
+        transaction_settings: SolarWindsAPM::Config[:transaction_settings]
+      }
+
+      unless otlp_endpoint.nil?
+        sampler_config.merge!({
+                                collector: "https://#{ENV.fetch('SW_APM_COLLECTOR', 'apm.collector.cloud.solarwinds.com:443')}",
+                                service: otlp_endpoint.service_name,
+                                headers: "Bearer #{otlp_endpoint.token}"
+                              })
+      end
+
+      sampler = is_lambda ? JsonSampler.new(sampler_config) : HttpSampler.new(sampler_config)
+
+      ::OpenTelemetry.tracer_provider.sampler = ::OpenTelemetry::SDK::Trace::Samplers.parent_based(
+        root: sampler,
+        remote_parent_sampled: sampler,
+        remote_parent_not_sampled: sampler
+      )
+
+      @@agent_enabled = true
+
+      nil
+    end
+
+    def self.[](key)
+      @@config[key.to_sym]
+    end
+
+    def self.agent_enabled
+      @@agent_enabled
+    end
+
+    def self.resolve_response_propagator
+      response_propagator  = SolarWindsAPM::OpenTelemetry::SolarWindsResponsePropagator::TextMapPropagator.new
+      rack_setting         = @@config_map['OpenTelemetry::Instrumentation::Rack']
+
+      if rack_setting
+        if rack_setting[:response_propagators].instance_of?(Array)
+          rack_setting[:response_propagators].append(response_propagator)
+        elsif rack_setting[:response_propagators].nil?
+          rack_setting[:response_propagators] = [response_propagator]
+        else
+          SolarWindsAPM.logger.warn do
+            "[#{name}/#{__method__}] Rack response propagator resolve failed. Provided type #{rack_setting[:response_propagators].class}, please provide Array e.g. [#{rack_setting[:response_propagators]}]"
+          end
+        end
+      else
+        @@config_map['OpenTelemetry::Instrumentation::Rack'] = { response_propagators: [response_propagator] }
+      end
+    end
+
+    #
+    # Allow initialize after set new value to SolarWindsAPM::Config[:key]=value
+    #
+    # Usage:
+    #
+    # Default using the use_all to load all instrumentation
+    # But with specific instrumentation disabled, use {:enabled: false} in config
+    # SolarWindsAPM::OTelNativeConfig.initialize_with_config do |config|
+    #   config["OpenTelemetry::Instrumentation::Rack"]  = {"a" => "b"}
+    #   config["OpenTelemetry::Instrumentation::Dalli"] = {:enabled: false}
+    #   config["RESOURCE_ATTRIBUTES"] = ::OpenTelemetry::Resource::Detector::GoogleCloudPlatform.detect
+    # end
+    #
+    def self.initialize_with_config
+      unless block_given?
+        SolarWindsAPM.logger.warn do
+          "[#{name}/#{__method__}] Block not given while doing in-code configuration. Agent disabled."
+        end
+        return
+      end
+
+      yield @@config_map
+
+      if @@config_map.empty?
+        SolarWindsAPM.logger.warn do
+          "[#{name}/#{__method__}] No configuration given for in-code configuration. Agent disabled."
+        end
+        return
+      end
+
+      initialize
+    end
+  end
+end

data/lib/solarwinds_apm/patch/README.md

@@ -0,0 +1,15 @@
+# Patch
+
+## Patch upstream code
+
+This folder is for storing patch files that apply to upstream code.
+
+For example, to patch otel ruby sdk `Registry`, and assume you have dummy_patch file that have module `SolarWindsAPM::Patch::DummyPatch`,
+
+```ruby
+require_relative './patch/dummy_patch'
+
+if defined? OpenTelemetry::Instrumentation::Registry && OpenTelemetry::Instrumentation::Registry::VERSION <= '0.3.0'
+  OpenTelemetry::Instrumentation::Registry.prepend(SolarWindsAPM::Patch::DummyPatch)
+end
+```

data/lib/solarwinds_apm/patch/tag_sql/sw_dbo_utils.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module SolarWindsAPM
+  module Patch
+    module TagSql
+      module SWODboUtils
+        def self.annotate_span_and_sql(sql)
+          return sql if sql.to_s.empty?
+
+          current_span = ::OpenTelemetry::Trace.current_span
+
+          annotated_sql = ''
+          if current_span.context.trace_flags.sampled?
+            traceparent = SolarWindsAPM::Utils.traceparent_from_context(current_span.context)
+            annotated_traceparent = "/*traceparent='#{traceparent}'*/"
+            current_span.add_attributes({ 'sw.query_tag' => annotated_traceparent })
+            annotated_sql = "#{sql} #{annotated_traceparent}"
+          else
+            annotated_sql = sql
+          end
+
+          SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] annotated_sql: #{annotated_sql}" }
+          annotated_sql
+        rescue StandardError => e
+          SolarWindsAPM.logger.error { "[#{self.class}/#{__method__}] Failed to annotated sql. Error: #{e.message}" }
+          sql
+        end
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/patch/tag_sql/sw_mysql2_patch.rb

@@ -11,18 +11,7 @@ module SolarWindsAPM
     module TagSql
       module SWOMysql2Patch
         def query(sql, options = {})
-          current_span = ::OpenTelemetry::Trace.current_span
-
-          annotated_sql = ''
-          if current_span.context.trace_flags.sampled?
-            traceparent = SolarWindsAPM::Utils.traceparent_from_context(current_span.context)
-            annotated_traceparent = "/*traceparent='#{traceparent}'*/"
-            current_span.add_attributes({ 'sw.query_tag' => annotated_traceparent })
-            annotated_sql = "#{sql} #{annotated_traceparent}"
-          else
-            annotated_sql = sql
-          end
-
+          annotated_sql = ::SolarWindsAPM::Patch::TagSql::SWODboUtils.annotate_span_and_sql(sql)
           super(annotated_sql, options)
         end
       end

data/lib/solarwinds_apm/patch/tag_sql/sw_pg_patch.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+module SolarWindsAPM
+  module Patch
+    module TagSql
+      module SWOPgPatch
+        # We target operations covered by the upstream pg instrumentation.
+        # These are all alike in that they will have a SQL
+        # statement as the first parameter, and they are all
+        # non-prepared statement execute.
+        EXEC_ISH_METHODS = %i[
+          exec
+          query
+          sync_exec
+          async_exec
+          exec_params
+          async_exec_params
+          sync_exec_params
+        ].freeze
+
+        EXEC_ISH_METHODS.each do |method|
+          define_method method do |*args|
+            annotated_sql = ::SolarWindsAPM::Patch::TagSql::SWODboUtils.annotate_span_and_sql(args[0])
+            args[0] = annotated_sql
+            super(*args)
+          end
+        end
+      end
+    end
+  end
+end
+
+# need to prepend before pg instrumentation patch itself
+# upstream instrumentation -> our patch -> original function
+PG::Connection.prepend(SolarWindsAPM::Patch::TagSql::SWOPgPatch) if defined?(PG::Connection)

data/lib/solarwinds_apm/patch/tag_sql_patch.rb

@@ -6,4 +6,6 @@
 #
 # 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 'tag_sql/sw_dbo_utils'
 require_relative 'tag_sql/sw_mysql2_patch'
+require_relative 'tag_sql/sw_pg_patch'

data/lib/solarwinds_apm/{noop/metadata.rb → sampling/dice.rb}

@@ -6,27 +6,29 @@
 #
 # 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.
 
-####
-# noop version of SolarWindsAPM::Metadata
-#
-module Oboe_metal # rubocop:disable Naming/ClassAndModuleCamelCase
-  # Metadata
-  class Metadata
-    ##
-    # noop version of :makeRandom
-    #
-    # needs to return an object that responds to :isValid
-    #
-    def self.makeRandom
-      Metadata.new
+# Dice is used in oboe_sampler diceRollAlgo
+module SolarWindsAPM
+  class Dice
+    attr_reader :rate, :scale
+
+    def initialize(settings)
+      @scale = settings[:scale]
+      @rate = settings[:rate] || 0
+    end
+
+    def update(settings)
+      @scale = settings[:scale] if settings[:scale]
+      @rate = settings[:rate] if settings[:rate]
     end
 
-    def self.fromString(*)
-      Metadata.new
+    # return Boolean
+    def roll
+      (rand * @scale) < @rate
     end
 
-    def isValid
-      false
+    def rate=(rate)
+      # Math.max(0, Math.min(this.#scale, n))
+      @rate = rate.clamp(0, @scale)
     end
   end
 end