solarwinds_apm 6.1.1 → 7.0.0.prev1

data/lib/solarwinds_apm/support/resource_detector/aws/eks.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'net/http'
+require 'json'
+require 'openssl'
+require 'uri'
+require 'opentelemetry/common'
+require 'opentelemetry/semantic_conventions/resource'
+
+module OpenTelemetry
+  module Resource
+    module Detector
+      module AWS
+        # EKS contains detect class method for determining EKS resource attributes
+        module EKS
+          extend self
+
+          # Container ID length from cgroup file
+          CONTAINER_ID_LENGTH = 64
+
+          # HTTP request timeout in seconds
+          HTTP_TIMEOUT = 5
+
+          # Kubernetes token and certificate paths
+          TOKEN_PATH = '/var/run/secrets/kubernetes.io/serviceaccount/token'
+          CERT_PATH = '/var/run/secrets/kubernetes.io/serviceaccount/ca.crt'
+
+          # Kubernetes API paths
+          AWS_AUTH_PATH = '/api/v1/namespaces/kube-system/configmaps/aws-auth'
+          CLUSTER_INFO_PATH = '/api/v1/namespaces/amazon-cloudwatch/configmaps/cluster-info'
+
+          # Create a constant for resource semantic conventions
+          RESOURCE = ::OpenTelemetry::SemanticConventions::Resource
+
+          def detect
+            # Return empty resource if not running on K8s
+            return ::OpenTelemetry::SDK::Resources::Resource.create({}) unless k8s?
+
+            resource_attributes = {}
+
+            begin
+              # Get K8s credentials
+              cred_value = k8s_cred_value
+
+              # Verify this is an EKS cluster
+              unless eks?(cred_value)
+                ::OpenTelemetry.logger.debug('Could not confirm process is running on EKS')
+                return ::OpenTelemetry::SDK::Resources::Resource.create({})
+              end
+
+              # Get cluster name and container ID
+              cluster_name_val = cluster_name(cred_value)
+              container_id_val = container_id
+
+              if container_id_val.empty? && cluster_name_val.empty?
+                ::OpenTelemetry.logger.debug('Neither cluster name nor container ID found on EKS process')
+                return ::OpenTelemetry::SDK::Resources::Resource.create({})
+              end
+
+              # Set resource attributes
+              resource_attributes[RESOURCE::CLOUD_PROVIDER] = 'aws'
+              resource_attributes[RESOURCE::CLOUD_PLATFORM] = 'aws_eks'
+              resource_attributes[RESOURCE::K8S_CLUSTER_NAME] = cluster_name_val unless cluster_name_val.empty?
+              resource_attributes[RESOURCE::CONTAINER_ID] = container_id_val unless container_id_val.empty?
+            rescue StandardError => e
+              ::OpenTelemetry.logger.debug("EKS resource detection failed: #{e.message}")
+              return ::OpenTelemetry::SDK::Resources::Resource.create({})
+            end
+
+            resource_attributes.delete_if { |_key, value| value.nil? || value.empty? }
+            ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+          end
+
+          private
+
+          # Check if running on K8s
+          #
+          # @return [Boolean] true if running on K8s
+          def k8s?
+            File.exist?(TOKEN_PATH) && File.exist?(CERT_PATH)
+          end
+
+          # Get K8s token
+          #
+          # @return [String] K8s token
+          # @raise [StandardError] if token could not be read
+          def k8s_cred_value
+            token = File.read(TOKEN_PATH).strip
+            "Bearer #{token}"
+          rescue StandardError => e
+            ::OpenTelemetry.logger.debug("Failed to get k8s token: #{e.message}")
+            raise e
+          end
+
+          # Check if running on EKS
+          #
+          # @param cred_value [String] K8s credentials
+          # @return [Boolean] true if running on EKS
+          def eks?(cred_value)
+            # Just try to to access the aws-auth configmap
+            # If it exists and we can access it, we're on EKS
+            aws_http_request(AWS_AUTH_PATH, cred_value)
+            true
+          rescue StandardError
+            false
+          end
+
+          # Get EKS cluster name
+          #
+          # @param cred_value [String] K8s credentials
+          # @return [String] Cluster name or empty string if not found
+          def cluster_name(cred_value)
+            begin
+              response = aws_http_request(CLUSTER_INFO_PATH, cred_value)
+              cluster_info = JSON.parse(response)
+              return cluster_info['data']['cluster.name'] if cluster_info['data'] && cluster_info['data']['cluster.name']
+            rescue StandardError => e
+              ::OpenTelemetry.logger.debug("Cannot get cluster name on EKS: #{e.message}")
+            end
+            ''
+          end
+
+          # Get container ID from cgroup file
+          #
+          # @return [String] Container ID or empty string if not found
+          def container_id
+            begin
+              File.open('/proc/self/cgroup', 'r') do |file|
+                file.each_line do |line|
+                  line = line.strip
+                  # Look for container ID (64 chars) at the end of the line
+                  return line[-CONTAINER_ID_LENGTH..] if line.length > CONTAINER_ID_LENGTH
+                end
+              end
+            rescue StandardError => e
+              ::OpenTelemetry.logger.debug("Failed to get container ID on EKS: #{e.message}")
+            end
+            ''
+          end
+
+          # Make HTTP GET request to K8s API
+          #
+          # @param path [String] API path
+          # @param cred_value [String] Authorization header value
+          # @return [String] Response body
+          # @raise [StandardError] if request fails
+          def aws_http_request(path, cred_value)
+            uri = URI.parse("https://kubernetes.default.svc#{path}")
+            http = Net::HTTP.new(uri.host, uri.port)
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+            http.ca_file = CERT_PATH
+            http.open_timeout = HTTP_TIMEOUT
+            http.read_timeout = HTTP_TIMEOUT
+
+            request = Net::HTTP::Get.new(uri)
+            request['Authorization'] = cred_value
+
+            ::OpenTelemetry::Common::Utilities.untraced do
+              response = http.request(request)
+              raise "HTTP request failed with status #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+              response.body
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/solarwinds_apm/support/resource_detector/aws/lambda.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# Copyright The OpenTelemetry Authors
+#
+# SPDX-License-Identifier: Apache-2.0
+
+require 'opentelemetry/semantic_conventions/resource'
+
+module OpenTelemetry
+  module Resource
+    module Detector
+      module AWS
+        # Lambda contains detect class method for determining Lambda resource attributes
+        module Lambda
+          extend self
+
+          # Create a constant for resource semantic conventions
+          RESOURCE = ::OpenTelemetry::SemanticConventions::Resource
+
+          def detect
+            # Return empty resource if not running on Lambda
+            return ::OpenTelemetry::SDK::Resources::Resource.create({}) unless lambda_environment?
+
+            resource_attributes = {}
+
+            begin
+              # Set Lambda-specific attributes from environment variables
+              resource_attributes[RESOURCE::CLOUD_PROVIDER] = 'aws'
+              resource_attributes[RESOURCE::CLOUD_PLATFORM] = 'aws_lambda'
+              resource_attributes[RESOURCE::CLOUD_REGION] = ENV.fetch('AWS_REGION', nil)
+              resource_attributes[RESOURCE::FAAS_NAME] = ENV.fetch('AWS_LAMBDA_FUNCTION_NAME', nil)
+              resource_attributes[RESOURCE::FAAS_VERSION] = ENV.fetch('AWS_LAMBDA_FUNCTION_VERSION', nil)
+              resource_attributes[RESOURCE::FAAS_INSTANCE] = ENV.fetch('AWS_LAMBDA_LOG_STREAM_NAME', nil)
+
+              # Convert memory size to integer
+              resource_attributes[RESOURCE::FAAS_MAX_MEMORY] = ENV['AWS_LAMBDA_FUNCTION_MEMORY_SIZE'].to_i if ENV['AWS_LAMBDA_FUNCTION_MEMORY_SIZE']
+            rescue StandardError => e
+              ::OpenTelemetry.handle_error(exception: e, message: 'Lambda resource detection failed')
+              return ::OpenTelemetry::SDK::Resources::Resource.create({})
+            end
+
+            # Filter out nil or empty values
+            # Note: we need to handle integers differently since they don't respond to empty?
+            resource_attributes.delete_if do |_key, value|
+              value.nil? || (value.respond_to?(:empty?) && value.empty?)
+            end
+
+            ::OpenTelemetry::SDK::Resources::Resource.create(resource_attributes)
+          end
+
+          private
+
+          # Determines if the current environment is AWS Lambda
+          #
+          # @return [Boolean] true if running on AWS Lambda
+          def lambda_environment?
+            # Check for Lambda-specific environment variables
+            !ENV['AWS_LAMBDA_FUNCTION_NAME'].nil? &&
+              !ENV['AWS_LAMBDA_FUNCTION_VERSION'].nil? &&
+              !ENV['AWS_LAMBDA_LOG_STREAM_NAME'].nil?
+          end
+        end
+      end
+    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_relative '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

data/lib/solarwinds_apm/support/service_key_checker.rb

@@ -10,19 +10,24 @@ module SolarWindsAPM
   # ServiceKeyChecker
   # It is a service that validate the service_key
   class ServiceKeyChecker
+    attr_reader :token, :service_name
+
     def initialize(reporter, is_lambda)
       @reporter = reporter
       @is_lambda = is_lambda
+      @token = nil
+      @service_name = nil
+      read_and_validate_service_key
     end
 
     def read_and_validate_service_key
-      return '' unless @reporter == 'ssl'
-      return '' if @is_lambda
+      return unless @reporter == 'ssl'
+      return if @is_lambda
 
       service_key = fetch_service_key
       if service_key.empty?
         SolarWindsAPM.logger.error { "[#{self.class}/#{__method__}] SW_APM_SERVICE_KEY not configured." }
-        return ''
+        return
       end
 
       token, _, service_name = parse_service_key(service_key)
@@ -30,7 +35,7 @@ module SolarWindsAPM
         SolarWindsAPM.logger.error do
           "[#{self.class}/#{__method__}] SW_APM_SERVICE_KEY problem. API Token in wrong format. Masked token: #{token[0..3]}...#{token[-4..]}"
         end
-        return ''
+        return
       end
 
       # if no service_name from service_key, then the SW_APM_SERVICE_KEY is not right format, return
@@ -39,7 +44,7 @@ module SolarWindsAPM
         SolarWindsAPM.logger.warn do
           "[#{self.class}/#{__method__}] SW_APM_SERVICE_KEY format problem. Service Name is missing."
         end
-        return ''
+        return
       end
 
       service_name = transform_service_name(service_name)
@@ -55,7 +60,8 @@ module SolarWindsAPM
         service_name = transform_service_name(otel_service_name)
       end
 
-      "#{token}:#{service_name}"
+      @token = token
+      @service_name = service_name
     end
 
     private

data/lib/solarwinds_apm/support/transaction_settings.rb

@@ -28,6 +28,12 @@ module SolarWindsAPM
 
     private
 
+    # def resolve_config
+    #   config = SolarWindsAPM::Config if defined?(SolarWindsAPM::Config)
+    #   config = SolarWindsAPM::OTelNativeConfig if defined?(SolarWindsAPM::OTelNativeConfig)
+    #   config
+    # end
+
     def tracing_enabled?
       span_layer = "#{@kind}:#{@name}"
 

data/lib/solarwinds_apm/support/txn_name_manager.rb

@@ -7,32 +7,69 @@
 # 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
-  # SolarWindsTxnNameManager
   # Transaction Name Manager is sole for enabling solarwinds api to call set_transaction_name
+  # 200 unique transaction naming per 60 seconds for the transaction naming
   class TxnNameManager
+    MAX_CARDINALITY = 200
+    DEFAULT_TXN_NAME = 'other'
+    TXN_NAME_POOL_TTL = 60 # 60s
+
+    # @root_context_h is used for trace api set_transaction_name;
+    #     it retrieve the span_id based on root trace_id
+    #     set_root_context_h(trace_id, span_flags)
+    # @cache store the transaction name that will be used for exporter
+    #     to set transaction name for attributes, get by trace_span_id
+    #     set(trace_span_id, transaction_name)
+    # @transaction_name store the transaction name and its expire call
+    #     set(transaction_name, thread {@cache.del()})
     def initialize
-      @cache = {}
-      @root_context_h = {}
+      @cache = {}            # for mapping trace_span_id to transaction name
+      @transaction_name = {} # only make sure the cardinality requirement that 200 unique txn within 60s
+      # use for setting DEFAULT_TXN_NAME (in @cache) when cardinality reach the maximal
+      @root_context_h = {} # for set_transaction_name api call
       @mutex = Mutex.new
+      @root_context_mutex = Mutex.new
     end
 
     def get(key)
-      @cache[key]
+      @mutex.synchronize { @cache[key] }
     end
 
     def del(key)
-      @cache.delete(key)
+      @mutex.synchronize { @cache.delete(key) }
     end
 
     def set(key, value)
-      @cache[key] = value
+      # new name and room in pool -> add name to pool and schedule for removal after ttl -> return name
+      # new name but no room in pool -> return default name
+      # existing name -> cancel previously scheduled removal -> schedule new removal -> return name
+      txn_name = value.slice(0, SolarWindsAPM::Constants::MAX_TXN_NAME_LENGTH)
+      txn_name_exist = false
+
+      # thread exit execute ensure block, better option than kill for sleep
+      @mutex.synchronize do
+        if @transaction_name[txn_name]
+          txn_name_exist = true
+          @transaction_name[txn_name].exit
+        end
+      end
+
+      @mutex.synchronize do
+        if txn_name_exist || @transaction_name.size < MAX_CARDINALITY
+          @cache[key] = txn_name
+          @transaction_name[txn_name] = Thread.new { cleanup_txn(key, txn_name) }
+        else
+          @cache[key] = DEFAULT_TXN_NAME
+        end
+      end
+
       SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] txn manager current cache #{@cache.inspect}" }
     end
 
     alias []= set
 
     def set_root_context_h(key, value)
-      @mutex.synchronize do
+      @root_context_mutex.synchronize do
         @root_context_h[key] = value
       end
       SolarWindsAPM.logger.debug do
@@ -41,13 +78,21 @@ module SolarWindsAPM
     end
 
     def get_root_context_h(key)
-      @root_context_h[key]
+      @root_context_mutex.synchronize { @root_context_h[key] }
     end
 
     def delete_root_context_h(key)
-      @mutex.synchronize do
+      @root_context_mutex.synchronize do
         @root_context_h.delete(key)
       end
     end
+
+    def cleanup_txn(_key, txn_name)
+      sleep(TXN_NAME_POOL_TTL)
+    ensure
+      @mutex.synchronize do
+        @transaction_name.delete(txn_name)
+      end
+    end
   end
 end

data/lib/solarwinds_apm/support/utils.rb

@@ -29,5 +29,14 @@ module SolarWindsAPM
       end
       xtr
     end
+
+    def self.determine_lambda
+      if ENV['LAMBDA_TASK_ROOT'].to_s.empty? && ENV['AWS_LAMBDA_FUNCTION_NAME'].to_s.empty?
+        false
+      else
+        SolarWindsAPM.logger.debug { "[#{self.class}/#{__method__}] lambda environment - LAMBDA_TASK_ROOT: #{ENV.fetch('LAMBDA_TASK_ROOT', nil)}; AWS_LAMBDA_FUNCTION_NAME: #{ENV.fetch('AWS_LAMBDA_FUNCTION_NAME', nil)}" }
+        true
+      end
+    end
   end
 end

data/lib/solarwinds_apm/support.rb

@@ -11,10 +11,9 @@
 require_relative 'support/logger_formatter'
 require_relative 'support/logging_log_event'
 require_relative 'support/lumberjack_formatter'
-require_relative 'support/transaction_cache'
 require_relative 'support/transaction_settings'
-require_relative 'support/oboe_tracing_mode'
 require_relative 'support/txn_name_manager'
 require_relative 'support/utils'
-require_relative 'support/x_trace_options'
-require_relative 'support/support_report'
+require_relative 'support/otlp_endpoint'
+require_relative 'support/resource_detector'
+require_relative 'support/aws_resource_detector'

data/lib/solarwinds_apm/version.rb

@@ -11,10 +11,10 @@ module SolarWindsAPM
   # The current version of the gem. Used mainly by
   # solarwinds_apm.gemspec during gem build process
   module Version
-    MAJOR  = 6 # breaking,
-    MINOR  = 1 # feature,
-    PATCH  = 1 # fix => BFF
-    PRE    = nil
+    MAJOR  = 7 # breaking,
+    MINOR  = 0 # feature,
+    PATCH  = 0 # fix => BFF
+    PRE    = 'prev1'
 
     STRING = [MAJOR, MINOR, PATCH, PRE].compact.join('.')
   end