solarwinds_apm 6.1.2 → 7.0.0.prev1

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/{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

data/lib/solarwinds_apm/sampling/http_sampler.rb

@@ -0,0 +1,87 @@
+# 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
+  class HttpSampler < Sampler
+    REQUEST_TIMEOUT = 10 # 10s
+    GET_SETTING_DURAION = 60 # 60s
+
+    # we don't need hostname as it's for separating browser and local env
+    def initialize(config)
+      super(config, SolarWindsAPM.logger)
+
+      @url = config[:collector]
+      @service = URI.encode_www_form_component(config[:service]) # service name "Hello world" -> "Hello%20world"
+      @headers = config[:headers]
+
+      @hostname = hostname
+      @setting_url = URI.join(@url, "./v1/settings/#{@service}/#{@hostname}")
+
+      Thread.new { settings_request }
+    end
+
+    private
+
+    # Node.js equivalent: Retrieve system hostname
+    # e.g. docker -> docker.swo.ubuntu.development; macos -> NHSDFWSSD
+    def hostname
+      host = Socket.gethostname
+      URI.encode_www_form_component(host)
+    end
+
+    def fetch_with_timeout(url, timeout_seconds = nil)
+      uri = url
+      response = nil
+
+      thread = Thread.new do
+        ::OpenTelemetry::Common::Utilities.untraced do
+          Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+            request = Net::HTTP::Get.new(uri)
+            request['Authorization'] = @headers
+
+            response = http.request(request)
+          end
+        end
+      rescue StandardError => e
+        @logger.debug { "Error during request: #{e.message}" }
+      end
+
+      thread_join = thread.join(timeout_seconds || REQUEST_TIMEOUT)
+      if thread_join.nil?
+        @logger.debug { "Request timed out after #{timeout_seconds} seconds" }
+        thread.kill
+      end
+
+      response
+    end
+
+    # a endless loop within a thread (non-blocking)
+    def settings_request
+      loop do
+        @logger.debug { "Retrieving sampling settings from #{@setting_url}" }
+
+        response = fetch_with_timeout(@setting_url)
+        parsed = response.nil? ? nil : JSON.parse(response.body)
+
+        @logger.debug { "parsed settings in json: #{parsed.inspect}" }
+
+        if update_settings(parsed)
+          # update the settings before the previous ones expire with some time to spare
+          expiry = (parsed['timestamp'].to_i + parsed['ttl'].to_i)
+          expiry_timeout = expiry - REQUEST_TIMEOUT - Time.now.to_i
+          sleep([0, expiry_timeout].max)
+        else
+          @logger.warn { 'Retrieved sampling settings are invalid. Ensure proper configuration.' }
+          sleep(GET_SETTING_DURAION)
+        end
+      rescue StandardError => e
+        @logger.warn { "Failed to retrieve sampling settings (#{e.message}), tracing will be disabled until valid ones are available." }
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/sampling/json_sampler.rb

@@ -0,0 +1,52 @@
+# 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
+  class JsonSampler < Sampler
+    DEFAULT_PATH = File.join(Dir.tmpdir, 'solarwinds-apm-settings.json')
+
+    def initialize(config, path = nil)
+      super(config, SolarWindsAPM.logger)
+
+      @path = path || DEFAULT_PATH
+      @expiry = Time.now.to_i
+      loop_check
+    end
+
+    # only json sampler will need to check if the settings.json file
+    # updated or not from collector extention
+    def should_sample?(params)
+      loop_check
+      super
+    end
+
+    private
+
+    def loop_check
+      # Update if we're within 10s of expiry
+      return if Time.now.to_i + 10 < @expiry
+
+      begin
+        contents = File.read(@path)
+        unparsed = JSON.parse(contents)
+      rescue StandardError => e
+        @logger.debug { "missing or invalid settings file; Error: #{e.message}" }
+        return
+      end
+
+      unless unparsed.is_a?(Array) && unparsed.length == 1
+        @logger.debug { "invalid settings file : #{unparsed}" }
+        return
+      end
+
+      parsed = update_settings(unparsed.first)
+      @logger.debug { "update_settings: #{parsed}" }
+      @expiry = parsed[:timestamp].to_i + parsed[:ttl].to_i if parsed
+    end
+  end
+end

data/lib/solarwinds_apm/sampling/metrics.rb

@@ -0,0 +1,38 @@
+# 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 Metrics
+    class Counter
+      # counter = Counter.new
+      # counter[:request_count].update(1)
+      def initialize
+        @meter = ::OpenTelemetry.meter_provider.meter('sw.apm.sampling.metrics')
+
+        @counter = {
+          request_count:
+            @meter.create_counter('trace.service.request_count', unit: '{request}', description: 'Count of all requests.'),
+          sample_count:
+            @meter.create_counter('trace.service.samplecount', unit: '{request}', description: 'Count of requests that went through sampling, which excludes those with a valid upstream decision or trigger traced.'),
+          trace_count:
+            @meter.create_counter('trace.service.tracecount', unit: '{trace}', description: 'Count of all traces.'),
+          through_trace_count:
+            @meter.create_counter('trace.service.through_trace_count', unit: '{request}', description: 'Count of requests with a valid upstream decision, thus passed through sampling.'),
+          triggered_trace_count:
+            @meter.create_counter('trace.service.triggered_trace_count', unit: '{trace}', description: 'Count of triggered traces.'),
+          token_bucket_exhaustion_count:
+            @meter.create_counter('trace.service.tokenbucket_exhaustion_count', unit: '{request}', description: 'Count of requests that were not traced due to token bucket rate limiting.')
+        }
+      end
+
+      def [](key)
+        @counter[key]
+      end
+    end
+  end
+end