solarwinds_apm 6.1.2 → 7.0.0.prev2

data/lib/solarwinds_apm/sampling/sampling_patch.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SolarWindsAPM
+  module MetricsExporter
+    module Patch
+      # do not send metrics if no data_points present
+      def export(metrics, timeout: nil)
+        metrics.reject! { |m| m.data_points.empty? }
+        return ::OpenTelemetry::SDK::Metrics::Export::SUCCESS unless metrics.any? { |m| m.data_points.any? }
+
+        super
+      end
+    end
+  end
+end
+
+module SolarWindsAPM
+  module Span
+    module Patch
+      def finish(end_timestamp: nil)
+        @mutex.synchronize do
+          if @ended
+            ::OpenTelemetry.logger.warn('Calling finish on an ended Span.')
+            return self
+          end
+        end
+
+        @span_processors.each do |processor|
+          processor.on_finishing(self) if processor.respond_to?(:on_finishing)
+        end
+
+        @mutex.synchronize do
+          @end_timestamp = relative_timestamp(end_timestamp)
+          @attributes = validated_attributes(@attributes).freeze
+          @events.freeze
+          @links.freeze
+          @ended = true
+        end
+        @span_processors.each { |processor| processor.on_finish(self) }
+        self
+      end
+    end
+  end
+end
+
+OpenTelemetry::Exporter::OTLP::Metrics::MetricsExporter.prepend(SolarWindsAPM::MetricsExporter::Patch)
+
+# issue: https://github.com/open-telemetry/opentelemetry-ruby/issues/1824
+OpenTelemetry::SDK::Trace::Span.prepend(SolarWindsAPM::Span::Patch)

data/lib/solarwinds_apm/sampling/setting_example.txt

@@ -0,0 +1 @@
+{"value"=>1000000, "flags"=>"SAMPLE_START,SAMPLE_THROUGH_ALWAYS,SAMPLE_BUCKET_ENABLED,TRIGGER_TRACE", "timestamp"=>1738523568, "ttl"=>120, "arguments"=>{"BucketCapacity"=>2, "BucketRate"=>1, "TriggerRelaxedBucketCapacity"=>20, "TriggerRelaxedBucketRate"=>1, "TriggerStrictBucketCapacity"=>6, "TriggerStrictBucketRate"=>0.1, "SignatureKey"=>"0sftj1EYX7JJp01DblJwkccYCIZ91fbU"}}

data/lib/solarwinds_apm/{noop/context.rb → sampling/settings.rb}

@@ -6,34 +6,23 @@
 #
 # 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::Context
-#
-# module SolarWindsAPM
-# end
+module SolarWindsAPM
+  module SamplingSettings
+    def self.merge(remote, local)
+      flags = local[:tracing_mode] || remote[:flags]
 
-module Oboe_metal # rubocop:disable Naming/ClassAndModuleCamelCase
-  # Context for noop
-  class Context
-    ##
-    # noop version of :toString
-    # toString would return the current trace context as string
-    #
-    def self.toString
-      '99-00000000000000000000000000000000-0000000000000000-00'
-    end
+      if local[:trigger_mode] == :enabled
+        flags |= SolarWindsAPM::Flags::TRIGGERED_TRACE
+      elsif local[:trigger_mode] == :disabled
+        flags &= ~ SolarWindsAPM::Flags::TRIGGERED_TRACE
+      end
 
-    def self.isReady(*)
-      false
-    end
+      if remote[:flags].anybits?(SolarWindsAPM::Flags::OVERRIDE)
+        flags &= remote[:flags]
+        flags |= SolarWindsAPM::Flags::OVERRIDE
+      end
 
-    def self.getDecisions(*)
-      [-1, -1, -1, 0, 0.0, 0.0, -1, -1, '', '', 4]
+      remote.dup.tap { |merged| merged[:flags] = flags }
     end
-
-    ##
-    # noop version of :clear
-    #
-    def self.clear; end
   end
 end

data/lib/solarwinds_apm/sampling/token_bucket.rb

@@ -0,0 +1,126 @@
+# 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.
+
+# Bucket is used to consume that determine if capacity is enough
+# capacity is updated through update_settings
+module SolarWindsAPM
+  class TokenBucket
+    # Maximum value of a signed 32-bit integer
+    MAX_INTERVAL = (2**31) - 1
+
+    attr_reader :capacity, :rate, :interval, :tokens
+
+    def initialize(token_bucket_settings)
+      self.capacity = token_bucket_settings.capacity || 0
+      self.rate = token_bucket_settings.rate || 0
+      self.interval = token_bucket_settings.interval || MAX_INTERVAL
+      self.tokens = @capacity
+      @timer = nil
+    end
+
+    # used call from update_settings e.g. bucket.update(bucket_settings)
+    def update(settings)
+      settings.instance_of?(Hash) ? update_from_hash(settings) : update_from_token_bucket_settings(settings)
+    end
+
+    def update_from_hash(settings)
+      if settings[:capacity]
+        difference = settings[:capacity] - @capacity
+        self.capacity = settings[:capacity]
+        self.tokens = @tokens + difference
+      end
+
+      self.rate = settings[:rate] if settings[:rate]
+
+      return unless settings[:interval]
+
+      self.interval = settings[:interval]
+      return unless running
+
+      stop
+      start
+    end
+
+    def update_from_token_bucket_settings(settings)
+      if settings.capacity
+        difference = settings.capacity - @capacity
+        self.capacity = settings.capacity
+        self.tokens = @tokens + difference
+      end
+
+      self.rate = settings.rate if settings.rate
+
+      return unless settings.interval
+
+      self.interval = settings.interval
+      return unless running
+
+      stop
+      start
+    end
+
+    def capacity=(capacity)
+      @capacity = [0, capacity].max
+    end
+
+    def rate=(rate)
+      @rate = [0, rate].max
+    end
+
+    def interval=(interval)
+      @interval = interval.clamp(0, MAX_INTERVAL)
+    end
+
+    def tokens=(tokens)
+      @tokens = tokens.clamp(0, @capacity)
+    end
+
+    # Attempts to consume tokens from the bucket
+    # @param n [Integer] Number of tokens to consume
+    # @return [Boolean] Whether there were enough tokens
+    def consume(token = 1)
+      if @tokens >= token
+        self.tokens = @tokens - token
+        true
+      else
+        false
+      end
+    end
+
+    # Starts replenishing the bucket
+    def start
+      return if running
+
+      @timer = Thread.new do
+        loop do
+          task
+          sleep(@interval / 1000.0)
+        end
+      end
+    end
+
+    # Stops replenishing the bucket
+    def stop
+      return unless running
+
+      @timer.kill
+      @timer = nil
+    end
+
+    # Whether the bucket is actively being replenished
+    def running
+      !@timer.nil?
+    end
+
+    private
+
+    def task
+      self.tokens = tokens + @rate
+    end
+  end
+end

data/lib/solarwinds_apm/sampling/trace_options.rb

@@ -0,0 +1,100 @@
+# 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 TraceOptions
+    TRIGGER_TRACE_KEY = 'trigger-trace'
+    TIMESTAMP_KEY = 'ts'
+    SW_KEYS_KEY = 'sw-keys'
+
+    CUSTOM_KEY_REGEX = /^custom-[^\s]*$/
+
+    def self.parse_trace_options(header, logger)
+      trace_options = TriggerTraceOptions.new(nil, nil, nil, {}, [], TraceOptionsResponse.new(nil, nil, []))
+
+      kvs = header.split(';').map do |kv|
+        key, *values = kv.split('=').map(&:strip)
+        value = values.any? ? values.join('=') : nil
+        [key, value]
+      end
+
+      kvs.reject! { |key, _| key.nil? || key.empty? }
+
+      kvs.each do |k, v|
+        case k
+        when TRIGGER_TRACE_KEY
+          if v || trace_options.trigger_trace
+            logger.debug { 'invalid trace option for trigger trace' }
+            trace_options.ignored << [k, v]
+            next
+          end
+          trace_options.trigger_trace = true
+        when TIMESTAMP_KEY
+          if v.nil? || trace_options.timestamp
+            logger.debug { 'invalid trace option for timestamp' }
+            trace_options.ignored << [k, v]
+            next
+          end
+
+          unless numeric_integer?(v)
+            logger.debug { 'invalid trace option for timestamp, should be an integer' }
+            trace_options.ignored << [k, v]
+            next
+          end
+          trace_options.timestamp = v.to_i
+        when SW_KEYS_KEY
+          if v.nil? || trace_options.sw_keys
+            logger.debug { 'invalid trace option for sw keys' }
+            trace_options.ignored << [k, v]
+            next
+          end
+          trace_options.sw_keys = v
+        when CUSTOM_KEY_REGEX
+          if v.nil? || trace_options.custom[k]
+            logger.debug { "invalid trace option for custom key #{k}" }
+            trace_options.ignored << [k, v]
+            next
+          end
+          trace_options.custom[k] = v
+        else
+          trace_options.ignored << [k, v]
+        end
+      end
+
+      trace_options
+    end
+
+    def self.numeric_integer?(str)
+      true if Integer(str)
+    rescue StandardError
+      false
+    end
+
+    # combine the array to string separate by ;
+    # tracestate doesn't accept value with k=v, here we use k:v
+    # but it will be replaced with = when inject in respond header
+    def self.stringify_trace_options_response(trace_options_response)
+      return if trace_options_response.nil?
+
+      kvs = {
+        auth: trace_options_response.auth,
+        'trigger-trace': trace_options_response.trigger_trace,
+        ignored: trace_options_response.ignored.empty? ? nil : trace_options_response.ignored.join(',')
+      }
+      kvs.compact.map { |k, v| "#{k}:#{v}" }.join(';')
+    end
+
+    def self.validate_signature(header, signature, key, timestamp)
+      return Auth::NO_SIGNATURE_KEY unless key
+      return Auth::BAD_TIMESTAMP unless timestamp && (Time.now.to_i - timestamp).abs <= 5 * 60
+
+      digest = OpenSSL::HMAC.hexdigest('SHA1', key, header)
+      signature == digest ? Auth::OK : Auth::BAD_SIGNATURE
+    end
+  end
+end

data/lib/solarwinds_apm/{patch.rb → sampling.rb}

@@ -6,8 +6,24 @@
 #
 # 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.
 
-# This file is for loading any customized patch for upstream
+require 'json'
+require 'fileutils'
+require 'tempfile'
+require 'uri'
+require 'opentelemetry-sdk'
 
-# e.g.
-# require_relative './patch/dummy_patch'
-# OpenTelemetry::Instrumentation::Registry.prepend(SolarWindsAPM::Patch::DummyPatch) if defined? OpenTelemetry::Instrumentation::Registry && OpenTelemetry::Instrumentation::Registry::VERSION <= '0.3.0'
+require_relative 'sampling/sampling_constants'
+require_relative 'sampling/dice'
+require_relative 'sampling/settings'
+require_relative 'sampling/token_bucket'
+require_relative 'sampling/trace_options'
+require_relative 'sampling/metrics'
+
+# HttpSampler/JsonSampler < Sampler < OboeSampler
+require_relative 'sampling/oboe_sampler'
+require_relative 'sampling/sampler'
+require_relative 'sampling/http_sampler'
+require_relative 'sampling/json_sampler'
+
+# Patching
+require_relative 'sampling/sampling_patch'

data/lib/solarwinds_apm/support/logger_formatter.rb

@@ -47,4 +47,4 @@ end
 
 # To use the trace context in log, ::Logger::Formatter.new must be defined
 # e.g. config.log_formatter = ::Logger::Formatter.new
-Logger::Formatter.prepend(SolarWindsAPM::Logger::Formatter) if SolarWindsAPM.loaded
+Logger::Formatter.prepend(SolarWindsAPM::Logger::Formatter)

data/lib/solarwinds_apm/support/logging_log_event.rb

@@ -23,4 +23,4 @@ module SolarWindsAPM
   end
 end
 
-Logging::LogEvent.prepend(SolarWindsAPM::Logging::LogEvent) if SolarWindsAPM.loaded && defined?(Logging::LogEvent)
+Logging::LogEvent.prepend(SolarWindsAPM::Logging::LogEvent) if defined?(Logging::LogEvent)

data/lib/solarwinds_apm/support/lumberjack_formatter.rb

@@ -23,4 +23,4 @@ module SolarWindsAPM
   end
 end
 
-Lumberjack::LogEntry.prepend(SolarWindsAPM::Lumberjack::LogEntry) if SolarWindsAPM.loaded && defined?(Lumberjack::LogEntry)
+Lumberjack::LogEntry.prepend(SolarWindsAPM::Lumberjack::LogEntry) if defined?(Lumberjack::LogEntry)

data/lib/solarwinds_apm/support/otlp_endpoint.rb

@@ -0,0 +1,99 @@
+# 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 'service_key_checker'
+
+module SolarWindsAPM
+  # OTLPEndPoint
+  class OTLPEndPoint
+    attr_reader :token, :service_name
+
+    SWO_APM_ENDPOINT_REGEX = /^apm\.collector\.([a-z]{2}-\d{2})\.([^.]+)\.solarwinds\.com(?::\d+)?$/
+    SWO_APM_ENDPOINT_DEFAULT = 'apm.collector.na-01.cloud.solarwinds.com:443'
+
+    SWO_OTLP_GENERAL_ENDPOINT_REGEX = %r{^https://otel\.collector\.[a-z0-9-]+\.[a-z0-9-]+\.solarwinds\.com(?::\d+)?$}
+    SWO_OTLP_SIGNAL_ENDPOINT_REGEX = %r{^https://otel\.collector\.[a-z0-9-]+\.[a-z0-9-]+\.solarwinds\.com(?::\d+)?/v1/(?:logs|metrics|traces)$}
+    SWO_OTLP_ENDPOINT_DEFAULT = 'https://otel.collector.na-01.cloud.solarwinds.com:443'
+
+    OTEL_SIGNAL_TYPE = %w[TRACES METRICS LOGS].freeze
+
+    def initialize
+      @token = nil
+      @service_name = nil
+    end
+
+    def config_otlp_token_and_endpoint
+      matches = ENV['SW_APM_COLLECTOR'].to_s.match(SWO_APM_ENDPOINT_REGEX)
+
+      resolve_get_setting_endpoint(matches)
+
+      service_key_checker = SolarWindsAPM::ServiceKeyChecker.new('ssl', SolarWindsAPM::Utils.determine_lambda)
+      @token = service_key_checker.token
+      @service_name = service_key_checker.service_name
+
+      OTEL_SIGNAL_TYPE.each do |data_type|
+        config_token(data_type)
+        configure_otlp_endpoint(data_type, matches)
+      end
+    end
+
+    # APM Libraries should only set the bearer token header as a convenience if:
+    # The OTEL config for exporter OTLP headers is not already set, i.e. explicitly configured by the end user, AND
+    # The OTLP export endpoint is SWO, i.e. host is otel.collector.*.*.solarwinds.com
+    def config_token(data_type)
+      data_type_upper = data_type.upcase
+
+      return unless @token
+
+      if ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_HEADERS"].to_s.empty? && ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_ENDPOINT"].to_s.match?(SWO_OTLP_SIGNAL_ENDPOINT_REGEX)
+        ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_HEADERS"] = "authorization=Bearer #{@token}"
+      elsif ENV['OTEL_EXPORTER_OTLP_HEADERS'].to_s.empty? && ENV['OTEL_EXPORTER_OTLP_ENDPOINT'].to_s.match?(SWO_OTLP_GENERAL_ENDPOINT_REGEX)
+        ENV['OTEL_EXPORTER_OTLP_HEADERS'] = "authorization=Bearer #{@token}"
+      end
+
+      ENV['OTEL_EXPORTER_OTLP_HEADERS'] = "authorization=Bearer #{@token}" if ENV['OTEL_EXPORTER_OTLP_HEADERS'].to_s.empty? && ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_HEADERS"].to_s.empty?
+    end
+
+    def configure_otlp_endpoint(data_type, matches)
+      data_type_upper = data_type.upcase
+      data_type_lower = data_type.downcase
+      otlp_endpoint_source = if ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_ENDPOINT"]
+                               "#{data_type_lower}_endpoint"
+                             elsif ENV['OTEL_EXPORTER_OTLP_ENDPOINT']
+                               'general_endpoint'
+                             else
+                               'no_endpoint'
+                             end
+
+      SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] otlp_endpoint_source: #{otlp_endpoint_source}" }
+
+      return unless otlp_endpoint_source == 'no_endpoint'
+
+      if matches&.size == 3
+        region = matches[1]
+        env    = matches[2]
+        ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_ENDPOINT"] = "https://otel.collector.#{region}.#{env}.solarwinds.com:443/v1/#{data_type_lower}"
+      else
+        ENV["OTEL_EXPORTER_OTLP_#{data_type_upper}_ENDPOINT"] = "https://otel.collector.na-01.cloud.solarwinds.com:443/v1/#{data_type_lower}"
+      end
+    end
+
+    # only valid value is apm.collector.*.*.solarwinds.com
+    # If SW APM config for collector is not set, the fallback: apm.collector.na-01.cloud.solarwinds.com
+    def resolve_get_setting_endpoint(matches)
+      return if matches&.size == 3
+
+      unless ENV['SW_APM_COLLECTOR'].to_s.empty?
+        SolarWindsAPM.logger.warn do
+          "[#{self.class}/#{__method__}] SW_APM_COLLECTOR format invalid: #{ENV.fetch('SW_APM_COLLECTOR', nil)}. Valid format: apm.collector.*.*.solarwinds.com"
+        end
+      end
+      ENV['SW_APM_COLLECTOR'] = SWO_APM_ENDPOINT_DEFAULT
+    end
+  end
+end

data/lib/solarwinds_apm/support/resource_detector.rb

@@ -0,0 +1,192 @@
+# 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 'net/http'
+require 'uri'
+require 'json'
+require 'socket'
+require 'securerandom'
+require 'opentelemetry/resource/detector/azure'
+require 'opentelemetry/resource/detector/container'
+require 'opentelemetry/resource/detector/aws/ec2'
+
+module SolarWindsAPM
+  # ResourceDetector
+  # Usage:
+  #   require 'opentelemetry/sdk'
+  #   require 'opentelemetry/resource/detector'
+  #   OpenTelemetry::SDK.configure do |c|
+  #     c.resource = SolarWindsAPM::ResourceDetector.detect
+  #   end
+  module ResourceDetector
+    K8S_PODNAME_PATH = '/etc/hostname'
+    K8S_NAMESPACE_PATH = '/var/run/secrets/kubernetes.io/serviceaccount/namespace'
+    K8S_NAMESPACE_PATH_WIN = 'C:\\var\\run\\secrets\\kubernetes.io\\serviceaccount\\namespace'
+    K8S_MOUNTINFO_FILE = '/proc/self/mountinfo'
+    UID_REGEX = /[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}/i
+
+    SW_K8S_NAMESPACE_ENV = 'SW_K8S_POD_NAMESPACE'
+    SW_K8S_UID_ENV = 'SW_K8S_POD_UID'
+    SW_K8S_NAME_ENV = 'SW_K8S_POD_NAME'
+
+    UAMS_CLIENT_PATH = '/opt/solarwinds/uamsclient/var/uamsclientid'
+    UAMS_CLIENT_PATH_WIN = 'C:\\ProgramData\\SolarWinds\\UAMSClient\\uamsclientid'
+    UAMS_CLIENT_URL = 'http://127.0.0.1:2113/info/uamsclient'
+    UAMS_CLIENT_ID_FIELD = 'uamsclient_id'
+
+    def self.detect
+      uuid_attr = { ::OpenTelemetry::SemanticConventions::Resource::SERVICE_INSTANCE_ID => random_uuid }
+      attributes = ::OpenTelemetry::SDK::Resources::Resource.create(uuid_attr)
+      attributes = attributes.merge(detect_uams_client_id)
+      attributes = attributes.merge(detect_k8s_attributes)
+      attributes = attributes.merge(detect_ec2)
+      attributes = attributes.merge(detect_azure)
+      attributes.merge(detect_container)
+    end
+
+    def self.detect_uams_client_id
+      uams_client_final_path = windows? ? UAMS_CLIENT_PATH_WIN : UAMS_CLIENT_PATH
+      uams_client_id = nil
+      begin
+        uams_client_id = File.read(uams_client_final_path).strip
+      rescue StandardError => e
+        SolarWindsAPM.logger.debug "#{self.class}/#{__method__}] uams file retrieve error #{e.message}."
+      end
+
+      if uams_client_id.nil?
+        begin
+          url = URI(UAMS_CLIENT_URL)
+
+          response = nil
+          ::OpenTelemetry::Common::Utilities.untraced do
+            http = Net::HTTP.new(url.host, url.port)
+            request = Net::HTTP::Get.new(url)
+            response = http.request(request)
+          end
+
+          raise 'Response returned non-200 status code' unless response&.code.to_i == 200
+
+          uams_metadata = JSON.parse(response.body)
+          uams_client_id = uams_metadata&.fetch(UAMS_CLIENT_ID_FIELD)
+        rescue StandardError => e
+          SolarWindsAPM.logger.debug "#{self.class}/#{__method__}] uams api retrieve error #{e.message}."
+        end
+      end
+
+      resource_attributes = {
+        'sw.uams.client.id' => uams_client_id,
+        'host.id' => uams_client_id
+      }
+
+      SolarWindsAPM.logger.debug "#{self.class}/#{__method__}] retrieved resource_attributes: #{resource_attributes.inspect}."
+      ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+    rescue StandardError => e
+      SolarWindsAPM.logger.debug "#{self.class}/#{__method__}] detect_uams_client_id failed. Error: #{e.message}."
+      ::OpenTelemetry::SDK::Resources::Resource.create({})
+    end
+
+    def self.detect_k8s_attributes
+      unless ENV['KUBERNETES_SERVICE_HOST'] && ENV['KUBERNETES_SERVICE_PORT']
+        SolarWindsAPM.logger.debug { "Can't read environment variable (KUBERNETES_SERVICE_HOST/KUBERNETES_SERVICE_PORT). It's likely not in kubernetes pod environment. No K8S resource detection." }
+        return ::OpenTelemetry::SDK::Resources::Resource.create({})
+      end
+
+      pod_name = ENV.fetch(SW_K8S_NAME_ENV, nil)
+      if pod_name.nil?
+        pod_name = Socket.gethostname
+      else
+        SolarWindsAPM.logger.debug { "read pod name from env #{pod_name}" }
+      end
+
+      pod_namespace = ENV.fetch(SW_K8S_NAMESPACE_ENV, nil)
+      if pod_namespace.nil?
+        begin
+          k8s_namspace_final_path = windows? ? K8S_NAMESPACE_PATH_WIN : K8S_NAMESPACE_PATH
+          pod_namespace = File.read(k8s_namspace_final_path).strip
+          SolarWindsAPM.logger.debug { 'read pod namespace from file' }
+        rescue StandardError => e
+          SolarWindsAPM.logger.debug { "can't read pod namespace #{e.message}" }
+        end
+      else
+        SolarWindsAPM.logger.debug { "read pod namespace from env #{pod_namespace}" }
+      end
+
+      pod_uid = ENV.fetch(SW_K8S_UID_ENV, nil)
+      if pod_uid.nil?
+        begin
+          File.open(K8S_MOUNTINFO_FILE) do |file|
+            file.each_line do |line|
+              fields = line.split
+              next if fields.size < 10
+
+              id, parent_id, _, root = fields
+              next unless safe_integer?(id) && safe_integer?(parent_id)
+              next unless root.include?('kube')
+
+              matches = UID_REGEX.match(root)
+              pod_uid = matches[0] if matches
+              break if pod_uid
+            end
+          end
+        rescue StandardError => e
+          SolarWindsAPM.logger.debug { "can't read pod uid #{e.message}" }
+        end
+      else
+        SolarWindsAPM.logger.debug { "read pod uid from env #{pod_uid}" }
+      end
+
+      resource_attributes = {
+        ::OpenTelemetry::SemanticConventions::Resource::K8S_NAMESPACE_NAME => pod_namespace,
+        ::OpenTelemetry::SemanticConventions::Resource::K8S_POD_NAME => pod_name,
+        ::OpenTelemetry::SemanticConventions::Resource::K8S_POD_UID => pod_uid
+      }
+
+      resource_attributes.compact!
+      SolarWindsAPM.logger.debug { "#{self.class}/#{__method__}] retrieved resource_attributes: #{resource_attributes.inspect}." }
+      ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+    end
+
+    def self.detect_ec2
+      attribute = ::OpenTelemetry::Resource::Detector::AWS::EC2.detect
+      SolarWindsAPM.logger.debug { "#{self.class}/#{__method__}] retrieved resource_attributes: #{attribute.instance_variable_get(:@attributes)}" }
+      attribute
+    rescue StandardError
+      ::OpenTelemetry::SDK::Resources::Resource.create({})
+    end
+
+    def self.detect_azure
+      attribute = ::OpenTelemetry::Resource::Detector::Azure.detect
+      SolarWindsAPM.logger.debug { "#{self.class}/#{__method__}] retrieved resource_attributes: #{attribute.instance_variable_get(:@attributes)}" }
+      attribute
+    rescue StandardError
+      ::OpenTelemetry::SDK::Resources::Resource.create({})
+    end
+
+    def self.detect_container
+      attribute = ::OpenTelemetry::Resource::Detector::Container.detect
+      SolarWindsAPM.logger.debug { "#{self.class}/#{__method__}] retrieved resource_attributes: #{attribute.instance_variable_get(:@attributes)}" }
+      attribute
+    rescue StandardError
+      ::OpenTelemetry::SDK::Resources::Resource.create({})
+    end
+
+    def self.safe_integer?(number)
+      min_safe_integer = -((2**53) - 1)
+      max_safe_integer = (2**53) - 1
+      number.is_a?(Integer) && number >= min_safe_integer && number <= max_safe_integer
+    end
+
+    def self.windows?
+      %w[mingw32 cygwin].any? { |platform| RUBY_PLATFORM.include?(platform) }
+    end
+
+    def self.random_uuid
+      SecureRandom.uuid
+    end
+  end
+end